mutex_unlock(&anx6345->lock);
 
        if (!num_modes && anx6345->panel)
-               num_modes += drm_panel_get_modes(anx6345->panel);
+               num_modes += drm_panel_get_modes(anx6345->panel, connector);
 
        return num_modes;
 }
 
        int ret, num_modes = 0;
 
        if (dp->plat_data->panel) {
-               num_modes += drm_panel_get_modes(dp->plat_data->panel);
+               num_modes += drm_panel_get_modes(dp->plat_data->panel, connector);
        } else {
                ret = analogix_dp_prepare_panel(dp, true, false);
                if (ret) {
 
        struct panel_bridge *panel_bridge =
                drm_connector_to_panel_bridge(connector);
 
-       return drm_panel_get_modes(panel_bridge->panel);
+       return drm_panel_get_modes(panel_bridge->panel, connector);
 }
 
 static const struct drm_connector_helper_funcs
 
 
        ps8622 = connector_to_ps8622(connector);
 
-       return drm_panel_get_modes(ps8622->panel);
+       return drm_panel_get_modes(ps8622->panel, connector);
 }
 
 static const struct drm_connector_helper_funcs ps8622_connector_helper_funcs = {
 
 {
        struct tc358764 *ctx = connector_to_tc358764(connector);
 
-       return drm_panel_get_modes(ctx->panel);
+       return drm_panel_get_modes(ctx->panel, connector);
 }
 
 static const
 
                return 0;
        }
 
-       count = drm_panel_get_modes(tc->panel);
+       count = drm_panel_get_modes(tc->panel, connector);
        if (count > 0)
                return count;
 
 
 {
        struct ti_sn_bridge *pdata = connector_to_ti_sn_bridge(connector);
 
-       return drm_panel_get_modes(pdata->panel);
+       return drm_panel_get_modes(pdata->panel, connector);
 }
 
 static enum drm_mode_status
 
  */
 int drm_panel_attach(struct drm_panel *panel, struct drm_connector *connector)
 {
-       if (panel->connector)
+       if (panel->drm)
                return -EBUSY;
 
-       panel->connector = connector;
        panel->drm = connector->dev;
 
        return 0;
  */
 void drm_panel_detach(struct drm_panel *panel)
 {
-       panel->connector = NULL;
        panel->drm = NULL;
 }
 EXPORT_SYMBOL(drm_panel_detach);
 /**
  * drm_panel_get_modes - probe the available display modes of a panel
  * @panel: DRM panel
+ * @connector: DRM connector
  *
  * The modes probed from the panel are automatically added to the connector
  * that the panel is attached to.
  * Return: The number of modes available from the panel on success or a
  * negative error code on failure.
  */
-int drm_panel_get_modes(struct drm_panel *panel)
+int drm_panel_get_modes(struct drm_panel *panel,
+                       struct drm_connector *connector)
 {
        if (!panel)
                return -EINVAL;
 
        if (panel->funcs && panel->funcs->get_modes)
-               return panel->funcs->get_modes(panel, panel->connector);
+               return panel->funcs->get_modes(panel, connector);
 
        return -EOPNOTSUPP;
 }
 
        }
 
        if (ctx->panel)
-               return drm_panel_get_modes(ctx->panel);
+               return drm_panel_get_modes(ctx->panel, connector);
 
        return 0;
 }
 
        struct exynos_dsi *dsi = connector_to_dsi(connector);
 
        if (dsi->panel)
-               return drm_panel_get_modes(dsi->panel);
+               return drm_panel_get_modes(dsi->panel, connector);
 
        return 0;
 }
 
        struct fsl_dcu_drm_connector *fsl_connector;
 
        fsl_connector = to_fsl_dcu_connector(connector);
-       return drm_panel_get_modes(fsl_connector->panel);
+       return drm_panel_get_modes(fsl_connector->panel, connector);
 }
 
 static int fsl_dcu_drm_connector_mode_valid(struct drm_connector *connector,
 
        struct imx_ldb_channel *imx_ldb_ch = con_to_imx_ldb_ch(connector);
        int num_modes;
 
-       num_modes = drm_panel_get_modes(imx_ldb_ch->panel);
+       num_modes = drm_panel_get_modes(imx_ldb_ch->panel, connector);
        if (num_modes > 0)
                return num_modes;
 
 
        struct device_node *np = imxpd->dev->of_node;
        int num_modes;
 
-       num_modes = drm_panel_get_modes(imxpd->panel);
+       num_modes = drm_panel_get_modes(imxpd->panel, connector);
        if (num_modes > 0)
                return num_modes;
 
 
 {
        struct mtk_dsi *dsi = connector_to_dsi(connector);
 
-       return drm_panel_get_modes(dsi->panel);
+       return drm_panel_get_modes(dsi->panel, connector);
 }
 
 static const struct drm_encoder_helper_funcs mtk_dsi_encoder_helper_funcs = {
 
        if (panel) {
                drm_panel_attach(panel, connector);
 
-               ret = drm_panel_get_modes(panel);
+               ret = drm_panel_get_modes(panel, connector);
 
                drm_panel_detach(panel);
        }
 
         * attached to the drm_panel.
         */
        drm_panel_attach(panel, connector);
-       num = drm_panel_get_modes(panel);
+       num = drm_panel_get_modes(panel, connector);
        if (!num)
                return 0;
 
 
                        drm_connector_to_mxsfb_drm_private(connector);
 
        if (mxsfb->panel)
-               return drm_panel_get_modes(mxsfb->panel);
+               return drm_panel_get_modes(mxsfb->panel, connector);
 
        return 0;
 }
 
         * operation to the panel API.
         */
        if (omap_connector->output->panel)
-               return drm_panel_get_modes(omap_connector->output->panel);
+               return drm_panel_get_modes(omap_connector->output->panel,
+                                          connector);
 
        /*
         * We can't retrieve modes, which can happen for instance for a DVI or
 
 {
        struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);
 
-       return drm_panel_get_modes(lvds->panel);
+       return drm_panel_get_modes(lvds->panel, connector);
 }
 
 static int rcar_lvds_connector_atomic_check(struct drm_connector *connector,
 
        struct rockchip_lvds *lvds = connector_to_lvds(connector);
        struct drm_panel *panel = lvds->panel;
 
-       return drm_panel_get_modes(panel);
+       return drm_panel_get_modes(panel, connector);
 }
 
 static const
 
        struct sti_dvo *dvo = dvo_connector->dvo;
 
        if (dvo->panel)
-               return drm_panel_get_modes(dvo->panel);
+               return drm_panel_get_modes(dvo->panel, connector);
 
        return 0;
 }
 
        struct sun4i_lvds *lvds =
                drm_connector_to_sun4i_lvds(connector);
 
-       return drm_panel_get_modes(lvds->panel);
+       return drm_panel_get_modes(lvds->panel, connector);
 }
 
 static struct drm_connector_helper_funcs sun4i_lvds_con_helper_funcs = {
 
        struct sun4i_rgb *rgb =
                drm_connector_to_sun4i_rgb(connector);
 
-       return drm_panel_get_modes(rgb->panel);
+       return drm_panel_get_modes(rgb->panel, connector);
 }
 
 /*
 
 {
        struct sun6i_dsi *dsi = connector_to_sun6i_dsi(connector);
 
-       return drm_panel_get_modes(dsi->panel);
+       return drm_panel_get_modes(dsi->panel, connector);
 }
 
 static struct drm_connector_helper_funcs sun6i_dsi_connector_helper_funcs = {
 
         * ignore any other means of obtaining a mode.
         */
        if (output->panel) {
-               err = drm_panel_get_modes(output->panel);
+               err = drm_panel_get_modes(output->panel, connector);
                if (err > 0)
                        return err;
        }
 
         */
        struct drm_device *drm;
 
-       /**
-        * @connector:
-        *
-        * DRM connector that the panel is attached to.
-        */
-       struct drm_connector *connector;
-
        /**
         * @dev:
         *
 int drm_panel_enable(struct drm_panel *panel);
 int drm_panel_disable(struct drm_panel *panel);
 
-int drm_panel_get_modes(struct drm_panel *panel);
+int drm_panel_get_modes(struct drm_panel *panel, struct drm_connector *connector);
 
 #if defined(CONFIG_OF) && defined(CONFIG_DRM_PANEL)
 struct drm_panel *of_drm_find_panel(const struct device_node *np);