static void imx_ldb_encoder_disable(struct drm_encoder *encoder) { struct imx_ldb_channel *imx_ldb_ch = enc_to_imx_ldb_ch(encoder); struct imx_ldb *ldb = imx_ldb_ch->ldb; /* * imx_ldb_encoder_disable is called by * drm_helper_disable_unused_functions without * the encoder being enabled before. */ if (imx_ldb_ch == &ldb->channel[0] && (ldb->ldb_ctrl & LDB_CH0_MODE_EN_MASK) == 0) return; else if (imx_ldb_ch == &ldb->channel[1] && (ldb->ldb_ctrl & LDB_CH1_MODE_EN_MASK) == 0) return; drm_panel_disable(imx_ldb_ch->panel); if (imx_ldb_ch == &ldb->channel[0]) ldb->ldb_ctrl &= ~LDB_CH0_MODE_EN_MASK; else if (imx_ldb_ch == &ldb->channel[1]) ldb->ldb_ctrl &= ~LDB_CH1_MODE_EN_MASK; regmap_write(ldb->regmap, IOMUXC_GPR2, ldb->ldb_ctrl); if (ldb->ldb_ctrl & LDB_SPLIT_MODE_EN) { clk_disable_unprepare(ldb->clk[0]); clk_disable_unprepare(ldb->clk[1]); } }
static void analogix_dp_bridge_disable(struct drm_bridge *bridge) { struct analogix_dp_device *dp = bridge->driver_private; int ret; if (dp->dpms_mode != DRM_MODE_DPMS_ON) return; if (dp->plat_data->panel) { if (drm_panel_disable(dp->plat_data->panel)) { DRM_ERROR("failed to disable the panel\n"); return; } } disable_irq(dp->irq); phy_power_off(dp->phy); if (dp->plat_data->power_off) dp->plat_data->power_off(dp->plat_data); pm_runtime_put_sync(dp->dev); ret = analogix_dp_prepare_panel(dp, false, true); if (ret) DRM_ERROR("failed to setup the panel ret = %d\n", ret); dp->dpms_mode = DRM_MODE_DPMS_OFF; }
static void imx_pd_encoder_disable(struct drm_encoder *encoder) { struct imx_parallel_display *imxpd = enc_to_imxpd(encoder); drm_panel_disable(imxpd->panel); drm_panel_unprepare(imxpd->panel); }
static void dw_mipi_dsi_encoder_disable(struct drm_encoder *encoder) { struct dw_mipi_dsi *dsi = encoder_to_dsi(encoder); drm_panel_disable(dsi->panel); if (clk_prepare_enable(dsi->pclk)) { dev_err(dsi->dev, "%s: Failed to enable pclk\n", __func__); return; } dw_mipi_dsi_set_mode(dsi, DW_MIPI_DSI_CMD_MODE); drm_panel_unprepare(dsi->panel); dw_mipi_dsi_set_mode(dsi, DW_MIPI_DSI_VID_MODE); /* * This is necessary to make sure the peripheral will be driven * normally when the display is enabled again later. */ msleep(120); dw_mipi_dsi_set_mode(dsi, DW_MIPI_DSI_CMD_MODE); dw_mipi_dsi_disable(dsi); clk_disable_unprepare(dsi->pclk); }
static void exynos_dp_bridge_disable(struct drm_bridge *bridge) { struct exynos_dp_device *dp = bridge->driver_private; struct exynos_drm_crtc *crtc = dp_to_crtc(dp); if (dp->dpms_mode != DRM_MODE_DPMS_ON) return; if (dp->panel) { if (drm_panel_disable(dp->panel)) { DRM_ERROR("failed to disable the panel\n"); return; } } disable_irq(dp->irq); flush_work(&dp->hotplug_work); phy_power_off(dp->phy); if (crtc->ops->clock_enable) crtc->ops->clock_enable(dp_to_crtc(dp), false); if (dp->panel) { if (drm_panel_unprepare(dp->panel)) DRM_ERROR("failed to turnoff the panel\n"); } pm_runtime_put_sync(dp->dev); dp->dpms_mode = DRM_MODE_DPMS_OFF; }
static void exynos_dpi_poweroff(struct exynos_dpi *ctx) { if (ctx->panel) { drm_panel_disable(ctx->panel); drm_panel_unprepare(ctx->panel); } }
static void imx_pd_encoder_dpms(struct drm_encoder *encoder, int mode) { struct imx_parallel_display *imxpd = enc_to_imxpd(encoder); if (mode != DRM_MODE_DPMS_ON) drm_panel_disable(imxpd->panel); else drm_panel_enable(imxpd->panel); }
static void exynos_dp_commit(struct drm_encoder *encoder) { struct exynos_dp_device *dp = encoder_to_dp(encoder); int ret; /* Keep the panel disabled while we configure video */ if (dp->panel) { if (drm_panel_disable(dp->panel)) DRM_ERROR("failed to disable the panel\n"); } ret = exynos_dp_detect_hpd(dp); if (ret) { /* Cable has been disconnected, we're done */ return; } ret = exynos_dp_handle_edid(dp); if (ret) { dev_err(dp->dev, "unable to handle edid\n"); return; } ret = exynos_dp_set_link_train(dp, dp->video_info->lane_count, dp->video_info->link_rate); if (ret) { dev_err(dp->dev, "unable to do link train\n"); return; } exynos_dp_enable_scramble(dp, 1); exynos_dp_enable_rx_to_enhanced_mode(dp, 1); exynos_dp_enable_enhanced_mode(dp, 1); exynos_dp_set_lane_count(dp, dp->video_info->lane_count); exynos_dp_set_link_bandwidth(dp, dp->video_info->link_rate); exynos_dp_init_video(dp); ret = exynos_dp_config_video(dp); if (ret) dev_err(dp->dev, "unable to config video\n"); /* Safe to enable the panel now */ if (dp->panel) { if (drm_panel_enable(dp->panel)) DRM_ERROR("failed to enable the panel\n"); } /* Enable video */ exynos_dp_start_video(dp); }
static void tegra_encoder_dpms(struct drm_encoder *encoder, int mode) { struct tegra_output *output = encoder_to_output(encoder); struct drm_panel *panel = output->panel; if (mode != DRM_MODE_DPMS_ON) { drm_panel_disable(panel); tegra_output_disable(output); drm_panel_unprepare(panel); } else { drm_panel_prepare(panel); tegra_output_enable(output); drm_panel_enable(panel); } }
static void rcar_lvds_disable(struct drm_bridge *bridge) { struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge); WARN_ON(!lvds->enabled); if (lvds->panel) { drm_panel_disable(lvds->panel); drm_panel_unprepare(lvds->panel); } rcar_lvds_write(lvds, LVDCR0, 0); rcar_lvds_write(lvds, LVDCR1, 0); clk_disable_unprepare(lvds->clock); lvds->enabled = false; }
static void imx_ldb_encoder_disable(struct drm_encoder *encoder) { struct imx_ldb_channel *imx_ldb_ch = enc_to_imx_ldb_ch(encoder); struct imx_ldb *ldb = imx_ldb_ch->ldb; int mux, ret; /* * imx_ldb_encoder_disable is called by * drm_helper_disable_unused_functions without * the encoder being enabled before. */ if (imx_ldb_ch == &ldb->channel[0] && (ldb->ldb_ctrl & LDB_CH0_MODE_EN_MASK) == 0) return; else if (imx_ldb_ch == &ldb->channel[1] && (ldb->ldb_ctrl & LDB_CH1_MODE_EN_MASK) == 0) return; drm_panel_disable(imx_ldb_ch->panel); if (imx_ldb_ch == &ldb->channel[0]) ldb->ldb_ctrl &= ~LDB_CH0_MODE_EN_MASK; else if (imx_ldb_ch == &ldb->channel[1]) ldb->ldb_ctrl &= ~LDB_CH1_MODE_EN_MASK; regmap_write(ldb->regmap, IOMUXC_GPR2, ldb->ldb_ctrl); if (ldb->ldb_ctrl & LDB_SPLIT_MODE_EN) { clk_disable_unprepare(ldb->clk[0]); clk_disable_unprepare(ldb->clk[1]); } if (ldb->lvds_mux) { const struct bus_mux *lvds_mux = NULL; if (imx_ldb_ch == &ldb->channel[0]) lvds_mux = &ldb->lvds_mux[0]; else if (imx_ldb_ch == &ldb->channel[1]) lvds_mux = &ldb->lvds_mux[1]; regmap_read(ldb->regmap, lvds_mux->reg, &mux); mux &= lvds_mux->mask; mux >>= lvds_mux->shift; } else {
static void mdp4_lcdc_encoder_disable(struct drm_encoder *encoder) { struct drm_device *dev = encoder->dev; struct mdp4_lcdc_encoder *mdp4_lcdc_encoder = to_mdp4_lcdc_encoder(encoder); struct mdp4_kms *mdp4_kms = get_kms(encoder); struct drm_panel *panel; int i, ret; if (WARN_ON(!mdp4_lcdc_encoder->enabled)) return; mdp4_write(mdp4_kms, REG_MDP4_LCDC_ENABLE, 0); panel = of_drm_find_panel(mdp4_lcdc_encoder->panel_node); if (!IS_ERR(panel)) { drm_panel_disable(panel); drm_panel_unprepare(panel); } /* * Wait for a vsync so we know the ENABLE=0 latched before * the (connector) source of the vsync's gets disabled, * otherwise we end up in a funny state if we re-enable * before the disable latches, which results that some of * the settings changes for the new modeset (like new * scanout buffer) don't latch properly.. */ mdp_irq_wait(&mdp4_kms->base, MDP4_IRQ_PRIMARY_VSYNC); clk_disable_unprepare(mdp4_lcdc_encoder->lcdc_clk); for (i = 0; i < ARRAY_SIZE(mdp4_lcdc_encoder->regs); i++) { ret = regulator_disable(mdp4_lcdc_encoder->regs[i]); if (ret) DRM_DEV_ERROR(dev->dev, "failed to disable regulator: %d\n", ret); } bs_set(mdp4_lcdc_encoder, 0); mdp4_lcdc_encoder->enabled = false; }
static void analogix_dp_commit(struct analogix_dp_device *dp) { int ret; /* Keep the panel disabled while we configure video */ if (dp->plat_data->panel) { if (drm_panel_disable(dp->plat_data->panel)) DRM_ERROR("failed to disable the panel\n"); } ret = analogix_dp_set_link_train(dp, dp->video_info.max_lane_count, dp->video_info.max_link_rate); if (ret) { dev_err(dp->dev, "unable to do link train\n"); return; } analogix_dp_enable_scramble(dp, 1); analogix_dp_enable_rx_to_enhanced_mode(dp, 1); analogix_dp_enable_enhanced_mode(dp, 1); analogix_dp_init_video(dp); ret = analogix_dp_config_video(dp); if (ret) dev_err(dp->dev, "unable to config video\n"); /* Safe to enable the panel now */ if (dp->plat_data->panel) { if (drm_panel_enable(dp->plat_data->panel)) DRM_ERROR("failed to enable the panel\n"); } /* Enable video */ analogix_dp_start_video(dp); dp->psr_support = analogix_dp_detect_sink_psr(dp); if (dp->psr_support) analogix_dp_enable_sink_psr(dp); }
static void exynos_dp_poweroff(struct exynos_drm_display *display) { struct exynos_dp_device *dp = display_to_dp(display); if (dp->dpms_mode != DRM_MODE_DPMS_ON) return; if (dp->panel) { if (drm_panel_disable(dp->panel)) { DRM_ERROR("failed to disable the panel\n"); return; } } disable_irq(dp->irq); flush_work(&dp->hotplug_work); exynos_dp_phy_exit(dp); clk_disable_unprepare(dp->clock); if (dp->panel) { if (drm_panel_unprepare(dp->panel)) DRM_ERROR("failed to turnoff the panel\n"); } }
static void dsi_mgr_bridge_post_disable(struct drm_bridge *bridge) { int id = dsi_mgr_bridge_get_id(bridge); struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id); struct msm_dsi *msm_dsi1 = dsi_mgr_get_dsi(DSI_1); struct mipi_dsi_host *host = msm_dsi->host; struct drm_panel *panel = msm_dsi->panel; bool is_dual_dsi = IS_DUAL_DSI(); int ret; DBG("id=%d", id); if (!msm_dsi_device_connected(msm_dsi)) return; /* * Do nothing with the host if it is slave-DSI in case of dual DSI. * It is safe to call dsi_mgr_phy_disable() here because a single PHY * won't be diabled until both PHYs request disable. */ if (is_dual_dsi && !IS_MASTER_DSI_LINK(id)) goto disable_phy; if (panel) { ret = drm_panel_disable(panel); if (ret) pr_err("%s: Panel %d OFF failed, %d\n", __func__, id, ret); } ret = msm_dsi_host_disable(host); if (ret) pr_err("%s: host %d disable failed, %d\n", __func__, id, ret); if (is_dual_dsi && msm_dsi1) { ret = msm_dsi_host_disable(msm_dsi1->host); if (ret) pr_err("%s: host1 disable failed, %d\n", __func__, ret); } if (panel) { ret = drm_panel_unprepare(panel); if (ret) pr_err("%s: Panel %d unprepare failed,%d\n", __func__, id, ret); } ret = msm_dsi_host_power_off(host); if (ret) pr_err("%s: host %d power off failed,%d\n", __func__, id, ret); if (is_dual_dsi && msm_dsi1) { ret = msm_dsi_host_power_off(msm_dsi1->host); if (ret) pr_err("%s: host1 power off failed, %d\n", __func__, ret); } disable_phy: dsi_mgr_phy_disable(id); }
static void exynos_dpi_poweroff(struct exynos_dpi *ctx) { if (ctx->panel) drm_panel_disable(ctx->panel); }