state->connectors[i].state);
                state->connectors[i].ptr = NULL;
                state->connectors[i].state = NULL;
-               drm_connector_unreference(connector);
+               drm_connector_put(connector);
        }
 
        for (i = 0; i < config->num_crtc; i++) {
        if (!connector_state)
                return ERR_PTR(-ENOMEM);
 
-       drm_connector_reference(connector);
+       drm_connector_get(connector);
        state->connectors[index].state = connector_state;
        state->connectors[index].old_state = connector->state;
        state->connectors[index].new_state = connector_state;
                crtc_state->connector_mask &=
                        ~(1 << drm_connector_index(conn_state->connector));
 
-               drm_connector_unreference(conn_state->connector);
+               drm_connector_put(conn_state->connector);
                conn_state->crtc = NULL;
        }
 
                crtc_state->connector_mask |=
                        1 << drm_connector_index(conn_state->connector);
 
-               drm_connector_reference(conn_state->connector);
+               drm_connector_get(conn_state->connector);
                conn_state->crtc = crtc;
 
                DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
 
 {
        memcpy(state, connector->state, sizeof(*state));
        if (state->crtc)
-               drm_connector_reference(connector);
+               drm_connector_get(connector);
 }
 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
 
 __drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
 {
        if (state->crtc)
-               drm_connector_unreference(state->connector);
+               drm_connector_put(state->connector);
 }
 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
 
 
  * als fixed panels or anything else that can display pixels in some form. As
  * opposed to all other KMS objects representing hardware (like CRTC, encoder or
  * plane abstractions) connectors can be hotplugged and unplugged at runtime.
- * Hence they are reference-counted using drm_connector_reference() and
- * drm_connector_unreference().
+ * Hence they are reference-counted using drm_connector_get() and
+ * drm_connector_put().
  *
  * KMS driver must create, initialize, register and attach at a &struct
  * drm_connector for each such sink. The instance is created as other KMS
        spin_unlock_irqrestore(&config->connector_list_lock, flags);
 
        if (old_conn)
-               drm_connector_unreference(old_conn);
+               drm_connector_put(old_conn);
 
        return iter->conn;
 }
 {
        iter->dev = NULL;
        if (iter->conn)
-               drm_connector_unreference(iter->conn);
+               drm_connector_put(iter->conn);
        lock_release(&connector_list_iter_dep_map, 0, _RET_IP_);
 }
 EXPORT_SYMBOL(drm_connector_list_iter_put);
 out:
        mutex_unlock(&dev->mode_config.mutex);
 out_unref:
-       drm_connector_unreference(connector);
+       drm_connector_put(connector);
 
        return ret;
 }
 
        if (connector_set) {
                for (i = 0; i < crtc_req->count_connectors; i++) {
                        if (connector_set[i])
-                               drm_connector_unreference(connector_set[i]);
+                               drm_connector_put(connector_set[i]);
                }
        }
        kfree(connector_set);
 
                        connector->dpms = DRM_MODE_DPMS_OFF;
 
                        /* we keep a reference while the encoder is bound */
-                       drm_connector_unreference(connector);
+                       drm_connector_put(connector);
                }
                drm_connector_list_iter_put(&conn_iter);
        }
        for (ro = 0; ro < set->num_connectors; ro++) {
                if (set->connectors[ro]->encoder)
                        continue;
-               drm_connector_reference(set->connectors[ro]);
+               drm_connector_get(set->connectors[ro]);
        }
 
        /* a) traverse passed in connector list and get encoders for them */
        for (ro = 0; ro < set->num_connectors; ro++) {
                if (set->connectors[ro]->encoder)
                        continue;
-               drm_connector_unreference(set->connectors[ro]);
+               drm_connector_put(set->connectors[ro]);
        }
 
        /* Try to restore the config */
 
                struct drm_fb_helper_connector *fb_helper_connector =
                        fb_helper->connector_info[i];
 
-               drm_connector_unreference(fb_helper_connector->connector);
+               drm_connector_put(fb_helper_connector->connector);
 
                kfree(fb_helper_connector);
                fb_helper->connector_info[i] = NULL;
        if (!fb_helper_connector)
                return -ENOMEM;
 
-       drm_connector_reference(connector);
+       drm_connector_get(connector);
        fb_helper_connector->connector = connector;
        fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
        return 0;
        if (i == fb_helper->connector_count)
                return -EINVAL;
        fb_helper_connector = fb_helper->connector_info[i];
-       drm_connector_unreference(fb_helper_connector->connector);
+       drm_connector_put(fb_helper_connector->connector);
 
        for (j = i + 1; j < fb_helper->connector_count; j++) {
                fb_helper->connector_info[j - 1] = fb_helper->connector_info[j];
        int i;
 
        for (i = 0; i < modeset->num_connectors; i++) {
-               drm_connector_unreference(modeset->connectors[i]);
+               drm_connector_put(modeset->connectors[i]);
                modeset->connectors[i] = NULL;
        }
        modeset->num_connectors = 0;
        int i;
 
        for (i = 0; i < helper->connector_count; i++) {
-               drm_connector_unreference(helper->connector_info[i]->connector);
+               drm_connector_put(helper->connector_info[i]->connector);
                kfree(helper->connector_info[i]);
        }
        kfree(helper->connector_info);
                        fb_crtc->y = offset->y;
                        modeset->mode = drm_mode_duplicate(dev,
                                                           fb_crtc->desired_mode);
-                       drm_connector_reference(connector);
+                       drm_connector_get(connector);
                        modeset->connectors[modeset->num_connectors++] = connector;
                        modeset->fb = fb_helper->fb;
                        modeset->x = offset->x;
 
                 * current connector itself, which means it is inherently safe
                 * against unreferencing the current connector - but not against
                 * deleting it right away. */
-               drm_connector_unreference(connector);
+               drm_connector_put(connector);
        }
        drm_connector_list_iter_put(&conn_iter);
        if (WARN_ON(!list_empty(&dev->mode_config.connector_list))) {
 
 }
 
 /**
- * drm_connector_reference - incr the connector refcnt
- * @connector: connector
+ * drm_connector_get - acquire a connector reference
+ * @connector: DRM connector
  *
  * This function increments the connector's refcount.
  */
+static inline void drm_connector_get(struct drm_connector *connector)
+{
+       drm_mode_object_get(&connector->base);
+}
+
+/**
+ * drm_connector_put - release a connector reference
+ * @connector: DRM connector
+ *
+ * This function decrements the connector's reference count and frees the
+ * object if the reference count drops to zero.
+ */
+static inline void drm_connector_put(struct drm_connector *connector)
+{
+       drm_mode_object_put(&connector->base);
+}
+
+/**
+ * drm_connector_reference - acquire a connector reference
+ * @connector: DRM connector
+ *
+ * This is a compatibility alias for drm_connector_get() and should not be
+ * used by new code.
+ */
 static inline void drm_connector_reference(struct drm_connector *connector)
 {
-       drm_mode_object_reference(&connector->base);
+       drm_connector_get(connector);
 }
 
 /**
- * drm_connector_unreference - unref a connector
- * @connector: connector to unref
+ * drm_connector_unreference - release a connector reference
+ * @connector: DRM connector
  *
- * This function decrements the connector's refcount and frees it if it drops to zero.
+ * This is a compatibility alias for drm_connector_put() and should not be
+ * used by new code.
  */
 static inline void drm_connector_unreference(struct drm_connector *connector)
 {
-       drm_mode_object_unreference(&connector->base);
+       drm_connector_put(connector);
 }
 
 const char *drm_get_connector_status_name(enum drm_connector_status status);
  *
  * Note that @connector is only valid within the list body, if you want to use
  * @connector after calling drm_connector_list_iter_put() then you need to grab
- * your own reference first using drm_connector_reference().
+ * your own reference first using drm_connector_get().
  */
 #define drm_for_each_connector_iter(connector, iter) \
        while ((connector = drm_connector_list_iter_next(iter)))
 
 |
 - drm_mode_object_unreference(object)
 + drm_mode_object_put(object)
+|
+- drm_connector_reference(object)
++ drm_connector_get(object)
+|
+- drm_connector_unreference(object)
++ drm_connector_put(object)
 )
 
 @r depends on report@
 drm_mode_object_unreference@p(object)
 |
 drm_mode_object_reference@p(object)
+|
+drm_connector_unreference@p(object)
+|
+drm_connector_reference@p(object)
 )
 
 @script:python depends on report@