return 0;
 }
 
-static enum drm_connector_status
-dce_virtual_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static int
 dce_virtual_set_property(struct drm_connector *connector,
                         struct drm_property *property,
 
 static const struct drm_connector_funcs dce_virtual_connector_funcs = {
        .dpms = dce_virtual_dpms,
-       .detect = dce_virtual_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .set_property = dce_virtual_set_property,
        .destroy = dce_virtual_destroy,
 
        return count;
 }
 
-static enum drm_connector_status
-arcpgu_drm_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void arcpgu_drm_connector_destroy(struct drm_connector *connector)
 {
        drm_connector_unregister(connector);
 static const struct drm_connector_funcs arcpgu_drm_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
        .reset = drm_atomic_helper_connector_reset,
-       .detect = arcpgu_drm_connector_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = arcpgu_drm_connector_destroy,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        kfree(connector);
 }
 
-static enum drm_connector_status
-ast_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_helper_funcs ast_connector_helper_funcs = {
        .mode_valid = ast_mode_valid,
        .get_modes = ast_get_modes,
 
 static const struct drm_connector_funcs ast_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .detect = ast_connector_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = ast_connector_destroy,
 };
 
        return NULL;
 }
 
-static enum drm_connector_status bochs_connector_detect(struct drm_connector
-                                                       *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_helper_funcs bochs_connector_connector_helper_funcs = {
        .get_modes = bochs_connector_get_modes,
        .mode_valid = bochs_connector_mode_valid,
 
 static const struct drm_connector_funcs bochs_connector_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .detect = bochs_connector_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = drm_connector_cleanup,
 };
 
        .get_modes = ptn3460_get_modes,
 };
 
-static enum drm_connector_status ptn3460_detect(struct drm_connector *connector,
-               bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_funcs ptn3460_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = ptn3460_detect,
        .destroy = drm_connector_cleanup,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        .get_modes = ps8622_get_modes,
 };
 
-static enum drm_connector_status ps8622_detect(struct drm_connector *connector,
-                                                               bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_funcs ps8622_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = ps8622_detect,
        .destroy = drm_connector_cleanup,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        return ret;
 }
 
-static enum drm_connector_status
-tc_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void tc_bridge_pre_enable(struct drm_bridge *bridge)
 {
        struct tc_data *tc = bridge_to_tc(bridge);
 static const struct drm_connector_funcs tc_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = tc_connector_detect,
        .destroy = drm_connector_cleanup,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        return NULL;
 }
 
-static enum drm_connector_status cirrus_vga_detect(struct drm_connector
-                                                  *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void cirrus_connector_destroy(struct drm_connector *connector)
 {
        drm_connector_cleanup(connector);
 
 static const struct drm_connector_funcs cirrus_vga_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .detect = cirrus_vga_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = cirrus_connector_destroy,
 };
 
 }
 EXPORT_SYMBOL(drm_kms_helper_poll_enable_locked);
 
+static enum drm_connector_status
+drm_connector_detect(struct drm_connector *connector, bool force)
+{
+       return connector->funcs->detect ?
+               connector->funcs->detect(connector, force) :
+               connector_status_connected;
+}
+
 /**
  * drm_helper_probe_single_connector_modes - get complete set of display modes
  * @connector: connector to probe
                if (connector->funcs->force)
                        connector->funcs->force(connector);
        } else {
-               connector->status = connector->funcs->detect(connector, true);
+               connector->status = drm_connector_detect(connector, true);
        }
 
        /*
 
                repoll = true;
 
-               connector->status = connector->funcs->detect(connector, false);
+               connector->status = drm_connector_detect(connector, false);
                if (old_status != connector->status) {
                        const char *old, *new;
 
 
                old_status = connector->status;
 
-               connector->status = connector->funcs->detect(connector, false);
+               connector->status = drm_connector_detect(connector, false);
                DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
                              connector->base.id,
                              connector->name,
 
        drm_connector_cleanup(connector);
 }
 
-static enum drm_connector_status
-fsl_dcu_drm_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_funcs fsl_dcu_drm_connector_funcs = {
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
        .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
        .destroy = fsl_dcu_drm_connector_destroy,
-       .detect = fsl_dcu_drm_connector_detect,
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .reset = drm_atomic_helper_connector_reset,
 
        REG_WRITE(PFIT_CONTROL, pfit_control);
 }
 
-/**
- * Detect the LVDS connection.
- *
- * This always returns CONNECTOR_STATUS_CONNECTED.
- * This connector should only have
- * been set up if the LVDS was actually connected anyway.
- */
-static enum drm_connector_status cdv_intel_lvds_detect(
-                               struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 /**
  * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
  */
 
 static const struct drm_connector_funcs cdv_intel_lvds_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .detect = cdv_intel_lvds_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .set_property = cdv_intel_lvds_set_property,
        .destroy = cdv_intel_lvds_destroy,
 
        REG_WRITE(PFIT_CONTROL, pfit_control);
 }
 
-/*
- * Detect the LVDS connection.
- *
- * This always returns CONNECTOR_STATUS_CONNECTED.
- * This connector should only have
- * been set up if the LVDS was actually connected anyway.
- */
-static enum drm_connector_status psb_intel_lvds_detect(struct drm_connector
-                                                  *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 /*
  * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
  */
 
 const struct drm_connector_funcs psb_intel_lvds_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .detect = psb_intel_lvds_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .set_property = psb_intel_lvds_set_property,
        .destroy = psb_intel_lvds_destroy,
 
        return drm_encoder_find(connector->dev, connector->encoder_ids[0]);
 }
 
-static enum drm_connector_status hibmc_connector_detect(struct drm_connector
-                                                *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_helper_funcs
        hibmc_connector_helper_funcs = {
        .get_modes = hibmc_connector_get_modes,
 
 static const struct drm_connector_funcs hibmc_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
-       .detect = hibmc_connector_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = drm_connector_cleanup,
        .reset = drm_atomic_helper_connector_reset,
 
        }
 }
 
-static enum drm_connector_status
-intel_dsi_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static int intel_dsi_get_modes(struct drm_connector *connector)
 {
        struct intel_connector *intel_connector = to_intel_connector(connector);
 
 static const struct drm_connector_funcs intel_dsi_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
-       .detect = intel_dsi_detect,
        .late_register = intel_connector_register,
        .early_unregister = intel_connector_unregister,
        .destroy = intel_dsi_connector_destroy,
 
        const struct bus_mux *lvds_mux;
 };
 
-static enum drm_connector_status imx_ldb_connector_detect(
-               struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void imx_ldb_ch_set_bus_format(struct imx_ldb_channel *imx_ldb_ch,
                                      u32 bus_format)
 {
 static const struct drm_connector_funcs imx_ldb_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = imx_ldb_connector_detect,
        .destroy = imx_drm_connector_destroy,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
                                 TVE_TVDAC_TEST_MODE_MASK, 1);
 }
 
-static enum drm_connector_status imx_tve_connector_detect(
-                               struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static int imx_tve_connector_get_modes(struct drm_connector *connector)
 {
        struct imx_tve *tve = con_to_tve(connector);
 static const struct drm_connector_funcs imx_tve_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = imx_tve_connector_detect,
        .destroy = imx_drm_connector_destroy,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        return container_of(e, struct imx_parallel_display, encoder);
 }
 
-static enum drm_connector_status imx_pd_connector_detect(
-               struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static int imx_pd_connector_get_modes(struct drm_connector *connector)
 {
        struct imx_parallel_display *imxpd = con_to_imxpd(connector);
 static const struct drm_connector_funcs imx_pd_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = imx_pd_connector_detect,
        .destroy = imx_drm_connector_destroy,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        mtk_output_dsi_enable(dsi);
 }
 
-static enum drm_connector_status mtk_dsi_connector_detect(
-       struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static int mtk_dsi_connector_get_modes(struct drm_connector *connector)
 {
        struct mtk_dsi *dsi = connector_to_dsi(connector);
 
 static const struct drm_connector_funcs mtk_dsi_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
-       .detect = mtk_dsi_connector_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = drm_connector_cleanup,
        .reset = drm_atomic_helper_connector_reset,
 
        return NULL;
 }
 
-static enum drm_connector_status mga_vga_detect(struct drm_connector
-                                                  *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void mga_connector_destroy(struct drm_connector *connector)
 {
        struct mga_connector *mga_connector = to_mga_connector(connector);
 
 static const struct drm_connector_funcs mga_vga_connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .detect = mga_vga_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = mga_connector_destroy,
 };
 
        .get_modes = rcar_du_lvds_connector_get_modes,
 };
 
-static enum drm_connector_status
-rcar_du_lvds_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_funcs connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .reset = drm_atomic_helper_connector_reset,
-       .detect = rcar_du_lvds_connector_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = drm_connector_cleanup,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        .mode_valid = dw_mipi_dsi_mode_valid,
 };
 
-static enum drm_connector_status
-dw_mipi_dsi_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void dw_mipi_dsi_drm_connector_destroy(struct drm_connector *connector)
 {
        drm_connector_unregister(connector);
 static struct drm_connector_funcs dw_mipi_dsi_atomic_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = dw_mipi_dsi_detect,
        .destroy = dw_mipi_dsi_drm_connector_destroy,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        drm_connector_cleanup(connector);
 }
 
-static enum drm_connector_status
-shmob_drm_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static const struct drm_connector_funcs connector_funcs = {
        .dpms = drm_helper_connector_dpms,
-       .detect = shmob_drm_connector_detect,
        .fill_modes = drm_helper_probe_single_connector_modes,
        .destroy = shmob_drm_connector_destroy,
 };
 
        .mode_valid = sti_hda_connector_mode_valid,
 };
 
-static enum drm_connector_status
-sti_hda_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static int sti_hda_late_register(struct drm_connector *connector)
 {
        struct sti_hda_connector *hda_connector
 static const struct drm_connector_funcs sti_hda_connector_funcs = {
        .dpms = drm_atomic_helper_connector_dpms,
        .fill_modes = drm_helper_probe_single_connector_modes,
-       .detect = sti_hda_connector_detect,
        .destroy = drm_connector_cleanup,
        .reset = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
        .mode_valid     = sun4i_rgb_mode_valid,
 };
 
-static enum drm_connector_status
-sun4i_rgb_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void
 sun4i_rgb_connector_destroy(struct drm_connector *connector)
 {
 
 static struct drm_connector_funcs sun4i_rgb_con_funcs = {
        .dpms                   = drm_atomic_helper_connector_dpms,
-       .detect                 = sun4i_rgb_connector_detect,
        .fill_modes             = drm_helper_probe_single_connector_modes,
        .destroy                = sun4i_rgb_connector_destroy,
        .reset                  = drm_atomic_helper_connector_reset,
 
        .mode_valid     = sun4i_tv_comp_mode_valid,
 };
 
-static enum drm_connector_status
-sun4i_tv_comp_connector_detect(struct drm_connector *connector, bool force)
-{
-       return connector_status_connected;
-}
-
 static void
 sun4i_tv_comp_connector_destroy(struct drm_connector *connector)
 {
 
 static struct drm_connector_funcs sun4i_tv_comp_connector_funcs = {
        .dpms                   = drm_atomic_helper_connector_dpms,
-       .detect                 = sun4i_tv_comp_connector_detect,
        .fill_modes             = drm_helper_probe_single_connector_modes,
        .destroy                = sun4i_tv_comp_connector_destroy,
        .reset                  = drm_atomic_helper_connector_reset,
 
        drm_connector_cleanup(connector);
 }
 
-static enum drm_connector_status panel_connector_detect(
-               struct drm_connector *connector,
-               bool force)
-{
-       return connector_status_connected;
-}
-
 static int panel_connector_get_modes(struct drm_connector *connector)
 {
        struct drm_device *dev = connector->dev;
 static const struct drm_connector_funcs panel_connector_funcs = {
        .destroy            = panel_connector_destroy,
        .dpms               = drm_atomic_helper_connector_dpms,
-       .detect             = panel_connector_detect,
        .fill_modes         = drm_helper_probe_single_connector_modes,
        .reset              = drm_atomic_helper_connector_reset,
        .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 
         * connector due to a user request. force can be used by the driver to
         * avoid expensive, destructive operations during automated probing.
         *
+        * This callback is optional, if not implemented the connector will be
+        * considered as always being attached.
+        *
         * FIXME:
         *
         * Note that this hook is only called by the probe helper. It's not in