#define PSR_WAIT_LINE_FLAG_TIMEOUT_MS  100
 
-#define to_dp(nm)      container_of(nm, struct rockchip_dp_device, nm)
-
 /**
  * struct rockchip_dp_chip_data - splite the grf setting of kind of chips
  * @lcdsel_grf_reg: grf register offset of lcdc select
 struct rockchip_dp_device {
        struct drm_device        *drm_dev;
        struct device            *dev;
-       struct drm_encoder       encoder;
+       struct rockchip_encoder  encoder;
        struct drm_display_mode  mode;
 
        struct clk               *pclk;
        struct analogix_dp_plat_data plat_data;
 };
 
+static struct rockchip_dp_device *encoder_to_dp(struct drm_encoder *encoder)
+{
+       struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
+
+       return container_of(rkencoder, struct rockchip_dp_device, encoder);
+}
+
+static struct rockchip_dp_device *pdata_encoder_to_dp(struct analogix_dp_plat_data *plat_data)
+{
+       return container_of(plat_data, struct rockchip_dp_device, plat_data);
+}
+
 static int rockchip_dp_pre_init(struct rockchip_dp_device *dp)
 {
        reset_control_assert(dp->rst);
 
 static int rockchip_dp_poweron_start(struct analogix_dp_plat_data *plat_data)
 {
-       struct rockchip_dp_device *dp = to_dp(plat_data);
+       struct rockchip_dp_device *dp = pdata_encoder_to_dp(plat_data);
        int ret;
 
        ret = clk_prepare_enable(dp->pclk);
 
 static int rockchip_dp_powerdown(struct analogix_dp_plat_data *plat_data)
 {
-       struct rockchip_dp_device *dp = to_dp(plat_data);
+       struct rockchip_dp_device *dp = pdata_encoder_to_dp(plat_data);
 
        clk_disable_unprepare(dp->pclk);
 
 static void rockchip_dp_drm_encoder_enable(struct drm_encoder *encoder,
                                           struct drm_atomic_state *state)
 {
-       struct rockchip_dp_device *dp = to_dp(encoder);
+       struct rockchip_dp_device *dp = encoder_to_dp(encoder);
        struct drm_crtc *crtc;
        struct drm_crtc_state *old_crtc_state;
        int ret;
 static void rockchip_dp_drm_encoder_disable(struct drm_encoder *encoder,
                                            struct drm_atomic_state *state)
 {
-       struct rockchip_dp_device *dp = to_dp(encoder);
+       struct rockchip_dp_device *dp = encoder_to_dp(encoder);
        struct drm_crtc *crtc;
        struct drm_crtc_state *new_crtc_state = NULL;
        int ret;
 
 static int rockchip_dp_drm_create_encoder(struct rockchip_dp_device *dp)
 {
-       struct drm_encoder *encoder = &dp->encoder;
+       struct drm_encoder *encoder = &dp->encoder.encoder;
        struct drm_device *drm_dev = dp->drm_dev;
        struct device *dev = dp->dev;
        int ret;
                return ret;
        }
 
-       dp->plat_data.encoder = &dp->encoder;
+       dp->plat_data.encoder = &dp->encoder.encoder;
 
        ret = analogix_dp_bind(dp->adp, drm_dev);
        if (ret)
 
        return 0;
 err_cleanup_encoder:
-       dp->encoder.funcs->destroy(&dp->encoder);
+       dp->encoder.encoder.funcs->destroy(&dp->encoder.encoder);
        return ret;
 }
 
        struct rockchip_dp_device *dp = dev_get_drvdata(dev);
 
        analogix_dp_unbind(dp->adp);
-       dp->encoder.funcs->destroy(&dp->encoder);
+       dp->encoder.encoder.funcs->destroy(&dp->encoder.encoder);
 }
 
 static const struct component_ops rockchip_dp_component_ops = {
 
 #include "cdn-dp-reg.h"
 #include "rockchip_drm_vop.h"
 
-#define connector_to_dp(c) \
-               container_of(c, struct cdn_dp_device, connector)
+static inline struct cdn_dp_device *connector_to_dp(struct drm_connector *connector)
+{
+       return container_of(connector, struct cdn_dp_device, connector);
+}
 
-#define encoder_to_dp(c) \
-               container_of(c, struct cdn_dp_device, encoder)
+static inline struct cdn_dp_device *encoder_to_dp(struct drm_encoder *encoder)
+{
+       struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
+
+       return container_of(rkencoder, struct cdn_dp_device, encoder);
+}
 
 #define GRF_SOC_CON9           0x6224
 #define DP_SEL_VOP_LIT         BIT(12)
 
        INIT_WORK(&dp->event_work, cdn_dp_pd_event_work);
 
-       encoder = &dp->encoder;
+       encoder = &dp->encoder.encoder;
 
        encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev,
                                                             dev->of_node);
 static void cdn_dp_unbind(struct device *dev, struct device *master, void *data)
 {
        struct cdn_dp_device *dp = dev_get_drvdata(dev);
-       struct drm_encoder *encoder = &dp->encoder;
+       struct drm_encoder *encoder = &dp->encoder.encoder;
        struct drm_connector *connector = &dp->connector;
 
        cancel_work_sync(&dp->event_work);
 
        struct device *dev;
        struct drm_device *drm_dev;
        struct drm_connector connector;
-       struct drm_encoder encoder;
+       struct rockchip_encoder encoder;
        struct drm_display_mode mode;
        struct platform_device *audio_pdev;
        struct work_struct event_work;
 
 
 #define HIWORD_UPDATE(val, mask)       (val | (mask) << 16)
 
-#define to_dsi(nm)     container_of(nm, struct dw_mipi_dsi_rockchip, nm)
-
 enum {
        DW_DSI_USAGE_IDLE,
        DW_DSI_USAGE_DSI,
 
 struct dw_mipi_dsi_rockchip {
        struct device *dev;
-       struct drm_encoder encoder;
+       struct rockchip_encoder encoder;
        void __iomem *base;
 
        struct regmap *grf_regmap;
        bool dsi_bound;
 };
 
+static struct dw_mipi_dsi_rockchip *to_dsi(struct drm_encoder *encoder)
+{
+       struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
+
+       return container_of(rkencoder, struct dw_mipi_dsi_rockchip, encoder);
+}
+
 struct dphy_pll_parameter_map {
        unsigned int max_mbps;
        u8 hsfreqrange;
        int ret, mux;
 
        mux = drm_of_encoder_active_endpoint_id(dsi->dev->of_node,
-                                               &dsi->encoder);
+                                               &dsi->encoder.encoder);
        if (mux < 0)
                return;
 
 static int rockchip_dsi_drm_create_encoder(struct dw_mipi_dsi_rockchip *dsi,
                                           struct drm_device *drm_dev)
 {
-       struct drm_encoder *encoder = &dsi->encoder;
+       struct drm_encoder *encoder = &dsi->encoder.encoder;
        int ret;
 
        encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev,
                goto out_pll_clk;
        }
 
-       ret = dw_mipi_dsi_bind(dsi->dmd, &dsi->encoder);
+       ret = dw_mipi_dsi_bind(dsi->dmd, &dsi->encoder.encoder);
        if (ret) {
                DRM_DEV_ERROR(dev, "Failed to bind: %d\n", ret);
                goto out_pll_clk;
 
 struct rockchip_hdmi {
        struct device *dev;
        struct regmap *regmap;
-       struct drm_encoder encoder;
+       struct rockchip_encoder encoder;
        const struct rockchip_hdmi_chip_data *chip_data;
        struct clk *vpll_clk;
        struct clk *grf_clk;
        struct phy *phy;
 };
 
-#define to_rockchip_hdmi(x)    container_of(x, struct rockchip_hdmi, x)
+static struct rockchip_hdmi *to_rockchip_hdmi(struct drm_encoder *encoder)
+{
+       struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
+
+       return container_of(rkencoder, struct rockchip_hdmi, encoder);
+}
 
 static const struct dw_hdmi_mpll_config rockchip_mpll_cfg[] = {
        {
        hdmi->dev = &pdev->dev;
        hdmi->chip_data = plat_data->phy_data;
        plat_data->phy_data = hdmi;
-       encoder = &hdmi->encoder;
+       encoder = &hdmi->encoder.encoder;
 
        encoder->possible_crtcs = drm_of_find_possible_crtcs(drm, dev->of_node);
        /*
 
 
 #include "inno_hdmi.h"
 
-#define to_inno_hdmi(x)        container_of(x, struct inno_hdmi, x)
-
 struct hdmi_data_info {
        int vic;
        bool sink_has_audio;
        void __iomem *regs;
 
        struct drm_connector    connector;
-       struct drm_encoder      encoder;
+       struct rockchip_encoder encoder;
 
        struct inno_hdmi_i2c *i2c;
        struct i2c_adapter *ddc;
        struct drm_display_mode previous_mode;
 };
 
+static struct inno_hdmi *encoder_to_inno_hdmi(struct drm_encoder *encoder)
+{
+       struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
+
+       return container_of(rkencoder, struct inno_hdmi, encoder);
+}
+
+static struct inno_hdmi *connector_to_inno_hdmi(struct drm_connector *connector)
+{
+       return container_of(connector, struct inno_hdmi, connector);
+}
+
 enum {
        CSC_ITU601_16_235_TO_RGB_0_255_8BIT,
        CSC_ITU601_0_255_TO_RGB_0_255_8BIT,
                                       struct drm_display_mode *mode,
                                       struct drm_display_mode *adj_mode)
 {
-       struct inno_hdmi *hdmi = to_inno_hdmi(encoder);
+       struct inno_hdmi *hdmi = encoder_to_inno_hdmi(encoder);
 
        inno_hdmi_setup(hdmi, adj_mode);
 
 
 static void inno_hdmi_encoder_enable(struct drm_encoder *encoder)
 {
-       struct inno_hdmi *hdmi = to_inno_hdmi(encoder);
+       struct inno_hdmi *hdmi = encoder_to_inno_hdmi(encoder);
 
        inno_hdmi_set_pwr_mode(hdmi, NORMAL);
 }
 
 static void inno_hdmi_encoder_disable(struct drm_encoder *encoder)
 {
-       struct inno_hdmi *hdmi = to_inno_hdmi(encoder);
+       struct inno_hdmi *hdmi = encoder_to_inno_hdmi(encoder);
 
        inno_hdmi_set_pwr_mode(hdmi, LOWER_PWR);
 }
 static enum drm_connector_status
 inno_hdmi_connector_detect(struct drm_connector *connector, bool force)
 {
-       struct inno_hdmi *hdmi = to_inno_hdmi(connector);
+       struct inno_hdmi *hdmi = connector_to_inno_hdmi(connector);
 
        return (hdmi_readb(hdmi, HDMI_STATUS) & m_HOTPLUG) ?
                connector_status_connected : connector_status_disconnected;
 
 static int inno_hdmi_connector_get_modes(struct drm_connector *connector)
 {
-       struct inno_hdmi *hdmi = to_inno_hdmi(connector);
+       struct inno_hdmi *hdmi = connector_to_inno_hdmi(connector);
        struct edid *edid;
        int ret = 0;
 
 
 static int inno_hdmi_register(struct drm_device *drm, struct inno_hdmi *hdmi)
 {
-       struct drm_encoder *encoder = &hdmi->encoder;
+       struct drm_encoder *encoder = &hdmi->encoder.encoder;
        struct device *dev = hdmi->dev;
 
        encoder->possible_crtcs = drm_of_find_possible_crtcs(drm, dev->of_node);
        return 0;
 err_cleanup_hdmi:
        hdmi->connector.funcs->destroy(&hdmi->connector);
-       hdmi->encoder.funcs->destroy(&hdmi->encoder);
+       hdmi->encoder.encoder.funcs->destroy(&hdmi->encoder.encoder);
 err_put_adapter:
        i2c_put_adapter(hdmi->ddc);
 err_disable_clk:
        struct inno_hdmi *hdmi = dev_get_drvdata(dev);
 
        hdmi->connector.funcs->destroy(&hdmi->connector);
-       hdmi->encoder.funcs->destroy(&hdmi->encoder);
+       hdmi->encoder.encoder.funcs->destroy(&hdmi->encoder.encoder);
 
        i2c_put_adapter(hdmi->ddc);
        clk_disable_unprepare(hdmi->pclk);
 
        void __iomem *regs;
 
        struct drm_connector connector;
-       struct drm_encoder encoder;
+       struct rockchip_encoder encoder;
 
        struct rk3066_hdmi_i2c *i2c;
        struct i2c_adapter *ddc;
        struct drm_display_mode previous_mode;
 };
 
-#define to_rk3066_hdmi(x) container_of(x, struct rk3066_hdmi, x)
+static struct rk3066_hdmi *encoder_to_rk3066_hdmi(struct drm_encoder *encoder)
+{
+       struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
+
+       return container_of(rkencoder, struct rk3066_hdmi, encoder);
+}
+
+static struct rk3066_hdmi *connector_to_rk3066_hdmi(struct drm_connector *connector)
+{
+       return container_of(connector, struct rk3066_hdmi, connector);
+}
 
 static inline u8 hdmi_readb(struct rk3066_hdmi *hdmi, u16 offset)
 {
                             struct drm_display_mode *mode,
                             struct drm_display_mode *adj_mode)
 {
-       struct rk3066_hdmi *hdmi = to_rk3066_hdmi(encoder);
+       struct rk3066_hdmi *hdmi = encoder_to_rk3066_hdmi(encoder);
 
        /* Store the display mode for plugin/DPMS poweron events. */
        memcpy(&hdmi->previous_mode, adj_mode, sizeof(hdmi->previous_mode));
 
 static void rk3066_hdmi_encoder_enable(struct drm_encoder *encoder)
 {
-       struct rk3066_hdmi *hdmi = to_rk3066_hdmi(encoder);
+       struct rk3066_hdmi *hdmi = encoder_to_rk3066_hdmi(encoder);
        int mux, val;
 
        mux = drm_of_encoder_active_endpoint_id(hdmi->dev->of_node, encoder);
 
 static void rk3066_hdmi_encoder_disable(struct drm_encoder *encoder)
 {
-       struct rk3066_hdmi *hdmi = to_rk3066_hdmi(encoder);
+       struct rk3066_hdmi *hdmi = encoder_to_rk3066_hdmi(encoder);
 
        DRM_DEV_DEBUG(hdmi->dev, "hdmi encoder disable\n");
 
 static enum drm_connector_status
 rk3066_hdmi_connector_detect(struct drm_connector *connector, bool force)
 {
-       struct rk3066_hdmi *hdmi = to_rk3066_hdmi(connector);
+       struct rk3066_hdmi *hdmi = connector_to_rk3066_hdmi(connector);
 
        return (hdmi_readb(hdmi, HDMI_HPG_MENS_STA) & HDMI_HPG_IN_STATUS_HIGH) ?
                connector_status_connected : connector_status_disconnected;
 
 static int rk3066_hdmi_connector_get_modes(struct drm_connector *connector)
 {
-       struct rk3066_hdmi *hdmi = to_rk3066_hdmi(connector);
+       struct rk3066_hdmi *hdmi = connector_to_rk3066_hdmi(connector);
        struct edid *edid;
        int ret = 0;
 
 static struct drm_encoder *
 rk3066_hdmi_connector_best_encoder(struct drm_connector *connector)
 {
-       struct rk3066_hdmi *hdmi = to_rk3066_hdmi(connector);
+       struct rk3066_hdmi *hdmi = connector_to_rk3066_hdmi(connector);
 
-       return &hdmi->encoder;
+       return &hdmi->encoder.encoder;
 }
 
 static int
 static int
 rk3066_hdmi_register(struct drm_device *drm, struct rk3066_hdmi *hdmi)
 {
-       struct drm_encoder *encoder = &hdmi->encoder;
+       struct drm_encoder *encoder = &hdmi->encoder.encoder;
        struct device *dev = hdmi->dev;
 
        encoder->possible_crtcs =
 
 err_cleanup_hdmi:
        hdmi->connector.funcs->destroy(&hdmi->connector);
-       hdmi->encoder.funcs->destroy(&hdmi->encoder);
+       hdmi->encoder.encoder.funcs->destroy(&hdmi->encoder.encoder);
 err_disable_i2c:
        i2c_put_adapter(hdmi->ddc);
 err_disable_hclk:
        struct rk3066_hdmi *hdmi = dev_get_drvdata(dev);
 
        hdmi->connector.funcs->destroy(&hdmi->connector);
-       hdmi->encoder.funcs->destroy(&hdmi->encoder);
+       hdmi->encoder.encoder.funcs->destroy(&hdmi->encoder.encoder);
 
        i2c_put_adapter(hdmi->ddc);
        clk_disable_unprepare(hdmi->hclk);
 
        struct drm_mm mm;
 };
 
+struct rockchip_encoder {
+       struct drm_encoder encoder;
+};
+
 int rockchip_drm_dma_attach_device(struct drm_device *drm_dev,
                                   struct device *dev);
 void rockchip_drm_dma_detach_device(struct drm_device *drm_dev,
 extern struct platform_driver rockchip_lvds_driver;
 extern struct platform_driver vop_platform_driver;
 extern struct platform_driver rk3066_hdmi_driver;
+
+static inline struct rockchip_encoder *to_rockchip_encoder(struct drm_encoder *encoder)
+{
+       return container_of(encoder, struct rockchip_encoder, encoder);
+}
+
 #endif /* _ROCKCHIP_DRM_DRV_H_ */
 
 
 struct rockchip_lvds;
 
-#define connector_to_lvds(c) \
-               container_of(c, struct rockchip_lvds, connector)
-
-#define encoder_to_lvds(c) \
-               container_of(c, struct rockchip_lvds, encoder)
-
 /**
  * struct rockchip_lvds_soc_data - rockchip lvds Soc private data
  * @probe: LVDS platform probe function
        struct drm_panel *panel;
        struct drm_bridge *bridge;
        struct drm_connector connector;
-       struct drm_encoder encoder;
+       struct rockchip_encoder encoder;
        struct dev_pin_info *pins;
 };
 
+static inline struct rockchip_lvds *connector_to_lvds(struct drm_connector *connector)
+{
+       return container_of(connector, struct rockchip_lvds, connector);
+}
+
+static inline struct rockchip_lvds *encoder_to_lvds(struct drm_encoder *encoder)
+{
+       struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
+
+       return container_of(rkencoder, struct rockchip_lvds, encoder);
+}
+
 static inline void rk3288_writel(struct rockchip_lvds *lvds, u32 offset,
                                 u32 val)
 {
                goto err_put_remote;
        }
 
-       encoder = &lvds->encoder;
+       encoder = &lvds->encoder.encoder;
        encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev,
                                                             dev->of_node);
 
        const struct drm_encoder_helper_funcs *encoder_funcs;
 
        encoder_funcs = lvds->soc_data->helper_funcs;
-       encoder_funcs->disable(&lvds->encoder);
+       encoder_funcs->disable(&lvds->encoder.encoder);
        pm_runtime_disable(dev);
        drm_connector_cleanup(&lvds->connector);
-       drm_encoder_cleanup(&lvds->encoder);
+       drm_encoder_cleanup(&lvds->encoder.encoder);
 }
 
 static const struct component_ops rockchip_lvds_component_ops = {