The connector is then registered with a call to
           <function>drm_connector_init</function> with a pointer to the connector
           functions and a connector type, and exposed through sysfs with a call to
-          <function>drm_sysfs_connector_add</function>.
+          <function>drm_connector_register</function>.
         </para>
         <para>
           Supported connector types are
        (<function>drm_encoder_cleanup</function>) and connectors
        (<function>drm_connector_cleanup</function>). Furthermore, connectors
        that have been added to sysfs must be removed by a call to
-       <function>drm_sysfs_connector_remove</function> before calling
+       <function>drm_connector_unregister</function> before calling
        <function>drm_connector_cleanup</function>.
       </para>
       <para>
        drm_encoder_helper_add(&intel_output->enc, &intel_crt_helper_funcs);
        drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 }]]></programlisting>
       <para>
         In the example above (taken from the i915 driver), a CRTC, connector and
 
 {
        struct armada_connector *dconn = drm_to_armada_conn(conn);
 
-       drm_sysfs_connector_remove(conn);
+       drm_connector_unregister(conn);
        drm_connector_cleanup(conn);
        kfree(dconn);
 }
        if (ret)
                goto err_conn;
 
-       ret = drm_sysfs_connector_add(&dconn->conn);
+       ret = drm_connector_register(&dconn->conn);
        if (ret)
                goto err_sysfs;
 
 
 {
        struct ast_connector *ast_connector = to_ast_connector(connector);
        ast_i2c_destroy(ast_connector->i2c);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
        connector->interlace_allowed = 0;
        connector->doublescan_allowed = 0;
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        connector->polled = DRM_CONNECTOR_POLL_CONNECT;
 
 
        }
        drm_connector_helper_add(&ptn_bridge->connector,
                        &ptn3460_connector_helper_funcs);
-       drm_sysfs_connector_add(&ptn_bridge->connector);
+       drm_connector_register(&ptn_bridge->connector);
        drm_mode_connector_attach_encoder(&ptn_bridge->connector, encoder);
 
        return 0;
 
 }
 EXPORT_SYMBOL(drm_connector_cleanup);
 
+/**
+ * drm_connector_register - register a connector
+ * @connector: the connector to register
+ *
+ * Register userspace interfaces for a connector
+ *
+ * Returns:
+ * Zero on success, error code on failure.
+ */
+int drm_connector_register(struct drm_connector *connector)
+{
+       return drm_sysfs_connector_add(connector);
+}
+EXPORT_SYMBOL(drm_connector_register);
+
+/**
+ * drm_connector_unregister - unregister a connector
+ * @connector: the connector to unregister
+ *
+ * Unregister userspace interfaces for a connector
+ */
+void drm_connector_unregister(struct drm_connector *connector)
+{
+       drm_sysfs_connector_remove(connector);
+}
+EXPORT_SYMBOL(drm_connector_unregister);
+
+
 /**
  * drm_connector_unplug_all - unregister connector userspace interfaces
  * @dev: drm device
 
        /* taking the mode config mutex ends up in a clash with sysfs */
        list_for_each_entry(connector, &dev->mode_config.connector_list, head)
-               drm_sysfs_connector_remove(connector);
+               drm_connector_unregister(connector);
 
 }
 EXPORT_SYMBOL(drm_connector_unplug_all);
 
 out:
        return ret;
 }
-EXPORT_SYMBOL(drm_sysfs_connector_add);
 
 /**
  * drm_sysfs_connector_remove - remove an connector device from sysfs
        device_unregister(connector->kdev);
        connector->kdev = NULL;
 }
-EXPORT_SYMBOL(drm_sysfs_connector_remove);
 
 /**
  * drm_sysfs_hotplug_event - generate a DRM uevent
 
        }
 
        drm_connector_helper_add(connector, &exynos_dp_connector_helper_funcs);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        drm_mode_connector_attach_encoder(connector, encoder);
 
        return 0;
 
        struct exynos_drm_connector *exynos_connector =
                to_exynos_connector(connector);
 
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(exynos_connector);
 }
        drm_connector_init(dev, connector, &exynos_connector_funcs, type);
        drm_connector_helper_add(connector, &exynos_connector_helper_funcs);
 
-       err = drm_sysfs_connector_add(connector);
+       err = drm_connector_register(connector);
        if (err)
                goto err_connector;
 
        return connector;
 
 err_sysfs:
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
 err_connector:
        drm_connector_cleanup(connector);
        kfree(exynos_connector);
 
 
 static void exynos_dpi_connector_destroy(struct drm_connector *connector)
 {
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
 }
 
        }
 
        drm_connector_helper_add(connector, &exynos_dpi_connector_helper_funcs);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        drm_mode_connector_attach_encoder(connector, encoder);
 
        return 0;
 
        }
 
        drm_connector_helper_add(connector, &exynos_dsi_connector_helper_funcs);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        drm_mode_connector_attach_encoder(connector, encoder);
 
        return 0;
 
        }
 
        drm_connector_helper_add(connector, &vidi_connector_helper_funcs);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        drm_mode_connector_attach_encoder(connector, encoder);
 
        return 0;
 
        }
 
        drm_connector_helper_add(connector, &hdmi_connector_helper_funcs);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        drm_mode_connector_attach_encoder(connector, encoder);
 
        return 0;
 
        struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
 
        psb_intel_i2c_destroy(gma_encoder->ddc_bus);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
        drm_connector_helper_add(connector,
                                        &cdv_intel_crt_connector_helper_funcs);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        return;
 failed_ddc:
 
                }
        }
        i2c_del_adapter(&intel_dp->adapter);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
        connector->interlace_allowed = false;
        connector->doublescan_allowed = false;
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        /* Set up the DDC bus. */
        switch (output_reg) {
 
 
        if (gma_encoder->i2c_bus)
                psb_intel_i2c_destroy(gma_encoder->i2c_bus);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
 
        hdmi_priv->hdmi_i2c_adapter = &(gma_encoder->i2c_bus->adapter);
        hdmi_priv->dev = dev;
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        return;
 
 failed_ddc:
 
 
        if (gma_encoder->i2c_bus)
                psb_intel_i2c_destroy(gma_encoder->i2c_bus);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
 
 out:
        mutex_unlock(&dev->mode_config.mutex);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        return;
 
 failed_find:
 
 
        if (!dsi_connector)
                return;
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        sender = dsi_connector->pkg_sender;
        mdfld_dsi_pkg_sender_destroy(sender);
        dsi_config->encoder = encoder;
        encoder->base.type = (pipe == 0) ? INTEL_OUTPUT_MIPI :
                INTEL_OUTPUT_MIPI2;
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        return;
 
        /*TODO: add code to destroy outputs on error*/
 
        connector->display_info.subpixel_order = SubPixelHorizontalRGB;
        connector->interlace_allowed = false;
        connector->doublescan_allowed = false;
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        dev_info(dev->dev, "HDMI initialised.\n");
 
        return;
 
 out:
        mutex_unlock(&dev->mode_config.mutex);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        return;
 
 failed_find:
 
 
        if (lvds_priv->ddc_bus)
                psb_intel_i2c_destroy(lvds_priv->ddc_bus);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
         */
 out:
        mutex_unlock(&dev->mode_config.mutex);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        return;
 
 failed_find:
 
                                     psb_intel_sdvo_connector->tv_format);
 
        psb_intel_sdvo_destroy_enhance_property(connector);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
        connector->base.base.display_info.subpixel_order = SubPixelHorizontalRGB;
 
        gma_connector_attach_encoder(&connector->base, &encoder->base);
-       drm_sysfs_connector_add(&connector->base.base);
+       drm_connector_register(&connector->base.base);
 }
 
 static void
 
 
        drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        if (!I915_HAS_HOTPLUG(dev))
                intel_connector->polled = DRM_CONNECTOR_POLL_CONNECT;
 
        struct drm_connector *connector = &intel_connector->base;
 
        intel_panel_destroy_backlight(connector);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
 }
 
 void intel_modeset_cleanup(struct drm_device *dev)
 
                          edp_panel_vdd_work);
 
        intel_connector_attach_encoder(intel_connector, intel_encoder);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        if (HAS_DDI(dev))
                intel_connector->get_hw_state = intel_ddi_connector_get_hw_state;
                        edp_panel_vdd_off_sync(intel_dp);
                        drm_modeset_unlock(&dev->mode_config.connection_mutex);
                }
-               drm_sysfs_connector_remove(connector);
+               drm_connector_unregister(connector);
                drm_connector_cleanup(connector);
                return false;
        }
 
 
        intel_connector_attach_encoder(intel_connector, intel_encoder);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        fixed_mode = dsi->dev_ops->get_modes(&intel_dsi->dev);
        if (!fixed_mode) {
 
                        intel_dvo->panel_wants_dither = true;
                }
 
-               drm_sysfs_connector_add(connector);
+               drm_connector_register(connector);
                return;
        }
 
 
        intel_hdmi_add_properties(intel_hdmi, connector);
 
        intel_connector_attach_encoder(intel_connector, intel_encoder);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
         * 0xd.  Failure to do so will result in spurious interrupts being
 
                DRM_DEBUG_KMS("lid notifier registration failed\n");
                lvds_connector->lid_notifier.notifier_call = NULL;
        }
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        intel_panel_init(&intel_connector->panel, fixed_mode, downclock_mode);
        intel_panel_setup_backlight(connector);
 
        connector->base.unregister = intel_sdvo_connector_unregister;
 
        intel_connector_attach_encoder(&connector->base, &encoder->base);
-       ret = drm_sysfs_connector_add(drm_connector);
+       ret = drm_connector_register(drm_connector);
        if (ret < 0)
                goto err1;
 
        return 0;
 
 err2:
-       drm_sysfs_connector_remove(drm_connector);
+       drm_connector_unregister(drm_connector);
 err1:
        drm_connector_cleanup(drm_connector);
 
        return true;
 
 err:
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        intel_sdvo_destroy(connector);
        return false;
 }
        return true;
 
 err:
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        intel_sdvo_destroy(connector);
        return false;
 }
        list_for_each_entry_safe(connector, tmp,
                                 &dev->mode_config.connector_list, head) {
                if (intel_attached_encoder(connector) == &intel_sdvo->base) {
-                       drm_sysfs_connector_remove(connector);
+                       drm_connector_unregister(connector);
                        intel_sdvo_destroy(connector);
                }
        }
 
        drm_object_attach_property(&connector->base,
                                   dev->mode_config.tv_bottom_margin_property,
                                   intel_tv->margin[TV_MARGIN_BOTTOM]);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 }
 
 
        drm_connector_helper_add(connector, &mga_vga_connector_helper_funcs);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        mga_connector->i2c = mgag200_i2c_create(dev);
        if (!mga_connector->i2c)
 
 
        hdp_disable(hdmi_connector);
 
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
 
        hdmi_unreference(hdmi_connector->hdmi);
        connector->interlace_allowed = 1;
        connector->doublescan_allowed = 0;
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        ret = hpd_enable(hdmi_connector);
        if (ret) {
 
        struct nouveau_connector *nv_connector = nouveau_connector(connector);
        nouveau_event_ref(NULL, &nv_connector->hpd);
        kfree(nv_connector->edid);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        if (nv_connector->aux.transfer)
                drm_dp_aux_unregister(&nv_connector->aux);
 
        INIT_WORK(&nv_connector->work, nouveau_connector_hotplug_work);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        return connector;
 }
 
        struct omap_dss_device *dssdev = omap_connector->dssdev;
 
        DBG("%s", omap_connector->dssdev->name);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(omap_connector);
 
        connector->interlace_allowed = 1;
        connector->doublescan_allowed = 0;
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        return connector;
 
 
        struct qxl_output *qxl_output =
                drm_connector_to_qxl_output(connector);
 
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(qxl_output);
 }
 
        drm_object_attach_property(&connector->base,
                                   qdev->hotplug_mode_update_property, 0);
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        return 0;
 }
 
 
        if (radeon_connector->edid)
                kfree(radeon_connector->edid);
        kfree(radeon_connector->con_priv);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
                connector->polled = DRM_CONNECTOR_POLL_HPD;
 
        connector->display_info.subpixel_order = subpixel_order;
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        if (has_aux)
                radeon_dp_aux_init(radeon_connector);
        } else
                connector->polled = DRM_CONNECTOR_POLL_HPD;
        connector->display_info.subpixel_order = subpixel_order;
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 }
 
 
 static void rcar_du_lvds_connector_destroy(struct drm_connector *connector)
 {
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
 }
 
                return ret;
 
        drm_connector_helper_add(connector, &connector_helper_funcs);
-       ret = drm_sysfs_connector_add(connector);
+       ret = drm_connector_register(connector);
        if (ret < 0)
                return ret;
 
 
 
 static void rcar_du_vga_connector_destroy(struct drm_connector *connector)
 {
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
 }
 
                return ret;
 
        drm_connector_helper_add(connector, &connector_helper_funcs);
-       ret = drm_sysfs_connector_add(connector);
+       ret = drm_connector_register(connector);
        if (ret < 0)
                return ret;
 
 
        struct shmob_drm_connector *scon = to_shmob_connector(connector);
 
        shmob_drm_backlight_exit(scon);
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
 }
 
                return ret;
 
        drm_connector_helper_add(connector, &connector_helper_funcs);
-       ret = drm_sysfs_connector_add(connector);
+       ret = drm_connector_register(connector);
        if (ret < 0)
                goto err_cleanup;
 
 err_backlight:
        shmob_drm_backlight_exit(&sdev->connector);
 err_sysfs:
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
 err_cleanup:
        drm_connector_cleanup(connector);
        return ret;
 
 
 static void tegra_connector_destroy(struct drm_connector *connector)
 {
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        drm_connector_clear(connector);
 }
        drm_encoder_helper_add(&output->encoder, &encoder_helper_funcs);
 
        drm_mode_connector_attach_encoder(&output->connector, &output->encoder);
-       drm_sysfs_connector_add(&output->connector);
+       drm_connector_register(&output->connector);
 
        output->encoder.possible_crtcs = 0x3;
 
 
        if (ret)
                goto fail;
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        return connector;
 
 
        if (ret)
                goto fail;
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        return connector;
 
 
        if (ret)
                goto fail;
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
 
        return connector;
 
 
 
 static void udl_connector_destroy(struct drm_connector *connector)
 {
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
 }
        drm_connector_init(dev, connector, &udl_connector_funcs, DRM_MODE_CONNECTOR_DVII);
        drm_connector_helper_add(connector, &udl_connector_helper_funcs);
 
-       drm_sysfs_connector_add(connector);
+       drm_connector_register(connector);
        drm_mode_connector_attach_encoder(connector, encoder);
 
        drm_object_attach_property(&connector->base,
 
                vmw_surface_unreference(&du->cursor_surface);
        if (du->cursor_dmabuf)
                vmw_dmabuf_unreference(&du->cursor_dmabuf);
-       drm_sysfs_connector_remove(&du->connector);
+       drm_connector_unregister(&du->connector);
        drm_crtc_cleanup(&du->crtc);
        drm_encoder_cleanup(&du->encoder);
        drm_connector_cleanup(&du->connector);
 
        encoder->possible_crtcs = (1 << unit);
        encoder->possible_clones = 0;
 
-       (void) drm_sysfs_connector_add(connector);
+       (void) drm_connector_register(connector);
 
        drm_crtc_init(dev, crtc, &vmw_legacy_crtc_funcs);
 
 
        encoder->possible_crtcs = (1 << unit);
        encoder->possible_clones = 0;
 
-       (void) drm_sysfs_connector_add(connector);
+       (void) drm_connector_register(connector);
 
        drm_crtc_init(dev, crtc, &vmw_screen_object_crtc_funcs);
 
 
 
 void imx_drm_connector_destroy(struct drm_connector *connector)
 {
-       drm_sysfs_connector_remove(connector);
+       drm_connector_unregister(connector);
        drm_connector_cleanup(connector);
 }
 EXPORT_SYMBOL_GPL(imx_drm_connector_destroy);
         * userspace will expect to be able to access DRM at this point.
         */
        list_for_each_entry(connector, &drm->mode_config.connector_list, head) {
-               ret = drm_sysfs_connector_add(connector);
+               ret = drm_connector_register(connector);
                if (ret) {
                        dev_err(drm->dev,
-                               "[CONNECTOR:%d:%s] drm_sysfs_connector_add failed: %d\n",
+                               "[CONNECTOR:%d:%s] drm_connector_register failed: %d\n",
                                connector->base.id,
                                connector->name, ret);
                        goto err_unbind;
 
                              struct drm_connector *connector,
                              const struct drm_connector_funcs *funcs,
                              int connector_type);
+int drm_connector_register(struct drm_connector *connector);
+void drm_connector_unregister(struct drm_connector *connector);
 
 extern void drm_connector_cleanup(struct drm_connector *connector);
 /* helper to unplug all connectors from sysfs for device */