case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1:
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2:
                drm_encoder_init(dev, encoder, &dce_v10_0_encoder_funcs,
-                                DRM_MODE_ENCODER_DAC);
+                                DRM_MODE_ENCODER_DAC, NULL);
                drm_encoder_helper_add(encoder, &dce_v10_0_dac_helper_funcs);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1:
                if (amdgpu_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
                        amdgpu_encoder->rmx_type = RMX_FULL;
                        drm_encoder_init(dev, encoder, &dce_v10_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_LVDS);
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_lcd_info(amdgpu_encoder);
                } else if (amdgpu_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT)) {
                        drm_encoder_init(dev, encoder, &dce_v10_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_DAC);
+                                        DRM_MODE_ENCODER_DAC, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_dig_info(amdgpu_encoder);
                } else {
                        drm_encoder_init(dev, encoder, &dce_v10_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_TMDS);
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_dig_info(amdgpu_encoder);
                }
                drm_encoder_helper_add(encoder, &dce_v10_0_dig_helper_funcs);
                amdgpu_encoder->is_ext_encoder = true;
                if (amdgpu_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT))
                        drm_encoder_init(dev, encoder, &dce_v10_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_LVDS);
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                else if (amdgpu_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT))
                        drm_encoder_init(dev, encoder, &dce_v10_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_DAC);
+                                        DRM_MODE_ENCODER_DAC, NULL);
                else
                        drm_encoder_init(dev, encoder, &dce_v10_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_TMDS);
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                drm_encoder_helper_add(encoder, &dce_v10_0_ext_helper_funcs);
                break;
        }
 
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1:
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2:
                drm_encoder_init(dev, encoder, &dce_v11_0_encoder_funcs,
-                                DRM_MODE_ENCODER_DAC);
+                                DRM_MODE_ENCODER_DAC, NULL);
                drm_encoder_helper_add(encoder, &dce_v11_0_dac_helper_funcs);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1:
                if (amdgpu_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
                        amdgpu_encoder->rmx_type = RMX_FULL;
                        drm_encoder_init(dev, encoder, &dce_v11_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_LVDS);
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_lcd_info(amdgpu_encoder);
                } else if (amdgpu_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT)) {
                        drm_encoder_init(dev, encoder, &dce_v11_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_DAC);
+                                        DRM_MODE_ENCODER_DAC, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_dig_info(amdgpu_encoder);
                } else {
                        drm_encoder_init(dev, encoder, &dce_v11_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_TMDS);
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_dig_info(amdgpu_encoder);
                }
                drm_encoder_helper_add(encoder, &dce_v11_0_dig_helper_funcs);
                amdgpu_encoder->is_ext_encoder = true;
                if (amdgpu_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT))
                        drm_encoder_init(dev, encoder, &dce_v11_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_LVDS);
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                else if (amdgpu_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT))
                        drm_encoder_init(dev, encoder, &dce_v11_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_DAC);
+                                        DRM_MODE_ENCODER_DAC, NULL);
                else
                        drm_encoder_init(dev, encoder, &dce_v11_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_TMDS);
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                drm_encoder_helper_add(encoder, &dce_v11_0_ext_helper_funcs);
                break;
        }
 
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1:
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2:
                drm_encoder_init(dev, encoder, &dce_v8_0_encoder_funcs,
-                                DRM_MODE_ENCODER_DAC);
+                                DRM_MODE_ENCODER_DAC, NULL);
                drm_encoder_helper_add(encoder, &dce_v8_0_dac_helper_funcs);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1:
                if (amdgpu_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
                        amdgpu_encoder->rmx_type = RMX_FULL;
                        drm_encoder_init(dev, encoder, &dce_v8_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_LVDS);
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_lcd_info(amdgpu_encoder);
                } else if (amdgpu_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT)) {
                        drm_encoder_init(dev, encoder, &dce_v8_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_DAC);
+                                        DRM_MODE_ENCODER_DAC, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_dig_info(amdgpu_encoder);
                } else {
                        drm_encoder_init(dev, encoder, &dce_v8_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_TMDS);
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                        amdgpu_encoder->enc_priv = amdgpu_atombios_encoder_get_dig_info(amdgpu_encoder);
                }
                drm_encoder_helper_add(encoder, &dce_v8_0_dig_helper_funcs);
                amdgpu_encoder->is_ext_encoder = true;
                if (amdgpu_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT))
                        drm_encoder_init(dev, encoder, &dce_v8_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_LVDS);
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                else if (amdgpu_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT))
                        drm_encoder_init(dev, encoder, &dce_v8_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_DAC);
+                                        DRM_MODE_ENCODER_DAC, NULL);
                else
                        drm_encoder_init(dev, encoder, &dce_v8_0_encoder_funcs,
-                                        DRM_MODE_ENCODER_TMDS);
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                drm_encoder_helper_add(encoder, &dce_v8_0_ext_helper_funcs);
                break;
        }
 
                return -ENOMEM;
 
        drm_encoder_init(dev, &ast_encoder->base, &ast_enc_funcs,
-                        DRM_MODE_ENCODER_DAC);
+                        DRM_MODE_ENCODER_DAC, NULL);
        drm_encoder_helper_add(&ast_encoder->base, &ast_enc_helper_funcs);
 
        ast_encoder->base.possible_crtcs = 1;
 
                               &atmel_hlcdc_panel_encoder_helper_funcs);
        ret = drm_encoder_init(dev, &panel->base.encoder,
                               &atmel_hlcdc_panel_encoder_funcs,
-                              DRM_MODE_ENCODER_LVDS);
+                              DRM_MODE_ENCODER_LVDS, NULL);
        if (ret)
                return ret;
 
 
 
        encoder->possible_crtcs = 0x1;
        drm_encoder_init(dev, encoder, &bochs_encoder_encoder_funcs,
-                        DRM_MODE_ENCODER_DAC);
+                        DRM_MODE_ENCODER_DAC, NULL);
        drm_encoder_helper_add(encoder, &bochs_encoder_helper_funcs);
 }
 
 
        encoder->possible_crtcs = 0x1;
 
        drm_encoder_init(dev, encoder, &cirrus_encoder_encoder_funcs,
-                        DRM_MODE_ENCODER_DAC);
+                        DRM_MODE_ENCODER_DAC, NULL);
        drm_encoder_helper_add(encoder, &cirrus_encoder_helper_funcs);
 
        return encoder;
 
  * @encoder: the encoder to init
  * @funcs: callbacks for this encoder
  * @encoder_type: user visible type of the encoder
+ * @name: printf style format string for the encoder name, or NULL for default name
  *
  * Initialises a preallocated encoder. Encoder should be
  * subclassed as part of driver encoder objects.
 int drm_encoder_init(struct drm_device *dev,
                      struct drm_encoder *encoder,
                      const struct drm_encoder_funcs *funcs,
-                     int encoder_type)
+                     int encoder_type, const char *name, ...)
 {
        int ret;
 
 
        DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 
        drm_encoder_init(drm_dev, encoder, &exynos_dp_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        drm_encoder_helper_add(encoder, &exynos_dp_encoder_helper_funcs);
 
 
        DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 
        drm_encoder_init(dev, encoder, &exynos_dpi_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        drm_encoder_helper_add(encoder, &exynos_dpi_encoder_helper_funcs);
 
 
        DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 
        drm_encoder_init(drm_dev, encoder, &exynos_dsi_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        drm_encoder_helper_add(encoder, &exynos_dsi_encoder_helper_funcs);
 
 
        DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 
        drm_encoder_init(drm_dev, encoder, &exynos_vidi_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        drm_encoder_helper_add(encoder, &exynos_vidi_encoder_helper_funcs);
 
 
        DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 
        drm_encoder_init(drm_dev, encoder, &exynos_hdmi_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        drm_encoder_helper_add(encoder, &exynos_hdmi_encoder_helper_funcs);
 
 
 
        encoder->possible_crtcs = 1;
        ret = drm_encoder_init(fsl_dev->drm, encoder, &encoder_funcs,
-                              DRM_MODE_ENCODER_LVDS);
+                              DRM_MODE_ENCODER_LVDS, NULL);
        if (ret < 0)
                return ret;
 
 
 
        encoder = &gma_encoder->base;
        drm_encoder_init(dev, encoder,
-               &cdv_intel_crt_enc_funcs, DRM_MODE_ENCODER_DAC);
+               &cdv_intel_crt_enc_funcs, DRM_MODE_ENCODER_DAC, NULL);
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
 
 
        encoder = &gma_encoder->base;
 
        drm_connector_init(dev, connector, &cdv_intel_dp_connector_funcs, type);
-       drm_encoder_init(dev, encoder, &cdv_intel_dp_enc_funcs, DRM_MODE_ENCODER_TMDS);
+       drm_encoder_init(dev, encoder, &cdv_intel_dp_enc_funcs,
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
 
 
                           DRM_MODE_CONNECTOR_DVID);
 
        drm_encoder_init(dev, encoder, &psb_intel_lvds_enc_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
        gma_encoder->type = INTEL_OUTPUT_HDMI;
 
 
        drm_encoder_init(dev, encoder,
                         &cdv_intel_lvds_enc_funcs,
-                        DRM_MODE_ENCODER_LVDS);
+                        DRM_MODE_ENCODER_LVDS, NULL);
 
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
 
        drm_encoder_init(dev,
                        encoder,
                        p_funcs->encoder_funcs,
-                       DRM_MODE_ENCODER_LVDS);
+                       DRM_MODE_ENCODER_LVDS, NULL);
        drm_encoder_helper_add(encoder,
                                p_funcs->encoder_helper_funcs);
 
 
 
        drm_encoder_init(dev, encoder,
                         &oaktrail_hdmi_enc_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
 
 
                           DRM_MODE_CONNECTOR_LVDS);
 
        drm_encoder_init(dev, encoder, &psb_intel_lvds_enc_funcs,
-                        DRM_MODE_ENCODER_LVDS);
+                        DRM_MODE_ENCODER_LVDS, NULL);
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
        gma_encoder->type = INTEL_OUTPUT_LVDS;
 
 
        drm_encoder_init(dev, encoder,
                         &psb_intel_lvds_enc_funcs,
-                        DRM_MODE_ENCODER_LVDS);
+                        DRM_MODE_ENCODER_LVDS, NULL);
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
        gma_encoder->type = INTEL_OUTPUT_LVDS;
 
        /* encoder type will be decided later */
        gma_encoder = &psb_intel_sdvo->base;
        gma_encoder->type = INTEL_OUTPUT_SDVO;
-       drm_encoder_init(dev, &gma_encoder->base, &psb_intel_sdvo_enc_funcs, 0);
+       drm_encoder_init(dev, &gma_encoder->base, &psb_intel_sdvo_enc_funcs,
+                        0, NULL);
 
        /* Read the regs to test if we can talk to the device */
        for (i = 0; i < 0x40; i++) {
 
 
        drm_encoder_helper_add(&priv->encoder, &tda998x_encoder_helper_funcs);
        ret = drm_encoder_init(drm, &priv->encoder, &tda998x_encoder_funcs,
-                              DRM_MODE_ENCODER_TMDS);
+                              DRM_MODE_ENCODER_TMDS, NULL);
        if (ret)
                goto err_encoder;
 
 
                           &intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA);
 
        drm_encoder_init(dev, &crt->base.base, &intel_crt_enc_funcs,
-                        DRM_MODE_ENCODER_DAC);
+                        DRM_MODE_ENCODER_DAC, NULL);
 
        intel_connector_attach_encoder(intel_connector, &crt->base);
 
 
        encoder = &intel_encoder->base;
 
        drm_encoder_init(dev, encoder, &intel_ddi_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        intel_encoder->compute_config = intel_ddi_compute_config;
        intel_encoder->enable = intel_enable_ddi;
 
        encoder = &intel_encoder->base;
 
        drm_encoder_init(dev, &intel_encoder->base, &intel_dp_enc_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        intel_encoder->compute_config = intel_dp_compute_config;
        intel_encoder->disable = intel_disable_dp;
 
        intel_mst->primary = intel_dig_port;
 
        drm_encoder_init(dev, &intel_encoder->base, &intel_dp_mst_enc_funcs,
-                        DRM_MODE_ENCODER_DPMST);
+                        DRM_MODE_ENCODER_DPMST, NULL);
 
        intel_encoder->type = INTEL_OUTPUT_DP_MST;
        intel_encoder->crtc_mask = 0x7;
 
 
        connector = &intel_connector->base;
 
-       drm_encoder_init(dev, encoder, &intel_dsi_funcs, DRM_MODE_ENCODER_DSI);
+       drm_encoder_init(dev, encoder, &intel_dsi_funcs, DRM_MODE_ENCODER_DSI,
+                        NULL);
 
        /* XXX: very likely not all of these are needed */
        intel_encoder->compute_config = intel_dsi_compute_config;
 
 
        intel_encoder = &intel_dvo->base;
        drm_encoder_init(dev, &intel_encoder->base,
-                        &intel_dvo_enc_funcs, encoder_type);
+                        &intel_dvo_enc_funcs, encoder_type, NULL);
 
        intel_encoder->disable = intel_disable_dvo;
        intel_encoder->enable = intel_enable_dvo;
 
        intel_encoder = &intel_dig_port->base;
 
        drm_encoder_init(dev, &intel_encoder->base, &intel_hdmi_enc_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        intel_encoder->compute_config = intel_hdmi_compute_config;
        if (HAS_PCH_SPLIT(dev)) {
 
                           DRM_MODE_CONNECTOR_LVDS);
 
        drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs,
-                        DRM_MODE_ENCODER_LVDS);
+                        DRM_MODE_ENCODER_LVDS, NULL);
 
        intel_encoder->enable = intel_enable_lvds;
        intel_encoder->pre_enable = intel_pre_enable_lvds;
 
        /* encoder type will be decided later */
        intel_encoder = &intel_sdvo->base;
        intel_encoder->type = INTEL_OUTPUT_SDVO;
-       drm_encoder_init(dev, &intel_encoder->base, &intel_sdvo_enc_funcs, 0);
+       drm_encoder_init(dev, &intel_encoder->base, &intel_sdvo_enc_funcs, 0,
+                        NULL);
 
        /* Read the regs to test if we can talk to the device */
        for (i = 0; i < 0x40; i++) {
 
                           DRM_MODE_CONNECTOR_SVIDEO);
 
        drm_encoder_init(dev, &intel_encoder->base, &intel_tv_enc_funcs,
-                        DRM_MODE_ENCODER_TVDAC);
+                        DRM_MODE_ENCODER_TVDAC, NULL);
 
        intel_encoder->compute_config = intel_tv_compute_config;
        intel_encoder->get_config = intel_tv_get_config;
 
 
        drm_encoder_helper_add(encoder, &dw_hdmi_imx_encoder_helper_funcs);
        drm_encoder_init(drm, encoder, &dw_hdmi_imx_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        return dw_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data);
 }
 
        drm_encoder_helper_add(&imx_ldb_ch->encoder,
                        &imx_ldb_encoder_helper_funcs);
        drm_encoder_init(drm, &imx_ldb_ch->encoder, &imx_ldb_encoder_funcs,
-                        DRM_MODE_ENCODER_LVDS);
+                        DRM_MODE_ENCODER_LVDS, NULL);
 
        drm_connector_helper_add(&imx_ldb_ch->connector,
                        &imx_ldb_connector_helper_funcs);
 
 
        drm_encoder_helper_add(&tve->encoder, &imx_tve_encoder_helper_funcs);
        drm_encoder_init(drm, &tve->encoder, &imx_tve_encoder_funcs,
-                        encoder_type);
+                        encoder_type, NULL);
 
        drm_connector_helper_add(&tve->connector,
                        &imx_tve_connector_helper_funcs);
 
 
        drm_encoder_helper_add(&imxpd->encoder, &imx_pd_encoder_helper_funcs);
        drm_encoder_init(drm, &imxpd->encoder, &imx_pd_encoder_funcs,
-                        DRM_MODE_ENCODER_NONE);
+                        DRM_MODE_ENCODER_NONE, NULL);
 
        drm_connector_helper_add(&imxpd->connector,
                        &imx_pd_connector_helper_funcs);
 
        encoder->possible_crtcs = 0x1;
 
        drm_encoder_init(dev, encoder, &mga_encoder_encoder_funcs,
-                        DRM_MODE_ENCODER_DAC);
+                        DRM_MODE_ENCODER_DAC, NULL);
        drm_encoder_helper_add(encoder, &mga_encoder_helper_funcs);
 
        return encoder;
 
        encoder = &mdp4_dtv_encoder->base;
 
        drm_encoder_init(dev, encoder, &mdp4_dtv_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
        drm_encoder_helper_add(encoder, &mdp4_dtv_encoder_helper_funcs);
 
        mdp4_dtv_encoder->src_clk = devm_clk_get(dev->dev, "src_clk");
 
        encoder = &mdp4_lcdc_encoder->base;
 
        drm_encoder_init(dev, encoder, &mdp4_lcdc_encoder_funcs,
-                        DRM_MODE_ENCODER_LVDS);
+                        DRM_MODE_ENCODER_LVDS, NULL);
        drm_encoder_helper_add(encoder, &mdp4_lcdc_encoder_helper_funcs);
 
        /* TODO: do we need different pll in other cases? */
 
        mdp5_cmd_enc->ctl = ctl;
 
        drm_encoder_init(dev, encoder, &mdp5_cmd_encoder_funcs,
-                       DRM_MODE_ENCODER_DSI);
+                       DRM_MODE_ENCODER_DSI, NULL);
 
        drm_encoder_helper_add(encoder, &mdp5_cmd_encoder_helper_funcs);
 
 
 
        spin_lock_init(&mdp5_encoder->intf_lock);
 
-       drm_encoder_init(dev, encoder, &mdp5_encoder_funcs, enc_type);
+       drm_encoder_init(dev, encoder, &mdp5_encoder_funcs, enc_type, NULL);
 
        drm_encoder_helper_add(encoder, &mdp5_encoder_helper_funcs);
 
 
        else
                helper = &nv04_dac_helper_funcs;
 
-       drm_encoder_init(dev, encoder, &nv04_dac_funcs, DRM_MODE_ENCODER_DAC);
+       drm_encoder_init(dev, encoder, &nv04_dac_funcs, DRM_MODE_ENCODER_DAC,
+                        NULL);
        drm_encoder_helper_add(encoder, helper);
 
        encoder->possible_crtcs = entry->heads;
 
        nv_encoder->dcb = entry;
        nv_encoder->or = ffs(entry->or) - 1;
 
-       drm_encoder_init(connector->dev, encoder, &nv04_dfp_funcs, type);
+       drm_encoder_init(connector->dev, encoder, &nv04_dfp_funcs, type, NULL);
        drm_encoder_helper_add(encoder, helper);
 
        encoder->possible_crtcs = entry->heads;
 
        /* Initialize the common members */
        encoder = to_drm_encoder(nv_encoder);
 
-       drm_encoder_init(dev, encoder, &nv04_tv_funcs, DRM_MODE_ENCODER_TVDAC);
+       drm_encoder_init(dev, encoder, &nv04_tv_funcs, DRM_MODE_ENCODER_TVDAC,
+                        NULL);
        drm_encoder_helper_add(encoder, &nv04_tv_helper_funcs);
 
        nv_encoder->enc_save = drm_i2c_encoder_save;
 
        tv_enc->base.dcb = entry;
        tv_enc->base.or = ffs(entry->or) - 1;
 
-       drm_encoder_init(dev, encoder, &nv17_tv_funcs, DRM_MODE_ENCODER_TVDAC);
+       drm_encoder_init(dev, encoder, &nv17_tv_funcs, DRM_MODE_ENCODER_TVDAC,
+                        NULL);
        drm_encoder_helper_add(encoder, &nv17_tv_helper_funcs);
        to_encoder_slave(encoder)->slave_funcs = &nv17_tv_slave_funcs;
 
 
        encoder = to_drm_encoder(nv_encoder);
        encoder->possible_crtcs = dcbe->heads;
        encoder->possible_clones = 0;
-       drm_encoder_init(connector->dev, encoder, &nv50_dac_func, type);
+       drm_encoder_init(connector->dev, encoder, &nv50_dac_func, type, NULL);
        drm_encoder_helper_add(encoder, &nv50_dac_hfunc);
 
        drm_mode_connector_attach_encoder(connector, encoder);
        encoder = to_drm_encoder(nv_encoder);
        encoder->possible_crtcs = dcbe->heads;
        encoder->possible_clones = 0;
-       drm_encoder_init(connector->dev, encoder, &nv50_sor_func, type);
+       drm_encoder_init(connector->dev, encoder, &nv50_sor_func, type, NULL);
        drm_encoder_helper_add(encoder, &nv50_sor_hfunc);
 
        drm_mode_connector_attach_encoder(connector, encoder);
        encoder = to_drm_encoder(nv_encoder);
        encoder->possible_crtcs = dcbe->heads;
        encoder->possible_clones = 0;
-       drm_encoder_init(connector->dev, encoder, &nv50_pior_func, type);
+       drm_encoder_init(connector->dev, encoder, &nv50_pior_func, type, NULL);
        drm_encoder_helper_add(encoder, &nv50_pior_hfunc);
 
        drm_mode_connector_attach_encoder(connector, encoder);
 
        encoder = &omap_encoder->base;
 
        drm_encoder_init(dev, encoder, &omap_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
        drm_encoder_helper_add(encoder, &omap_encoder_helper_funcs);
 
        return encoder;
 
                           &qxl_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
 
        drm_encoder_init(dev, &qxl_output->enc, &qxl_enc_funcs,
-                        DRM_MODE_ENCODER_VIRTUAL);
+                        DRM_MODE_ENCODER_VIRTUAL, NULL);
 
        /* we get HPD via client monitors config */
        connector->polled = DRM_CONNECTOR_POLL_HPD;
 
        case ENCODER_OBJECT_ID_INTERNAL_LVTM1:
                if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
                        radeon_encoder->rmx_type = RMX_FULL;
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_LVDS);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                        radeon_encoder->enc_priv = radeon_atombios_get_lvds_info(radeon_encoder);
                } else {
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_TMDS);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                        radeon_encoder->enc_priv = radeon_atombios_set_dig_info(radeon_encoder);
                }
                drm_encoder_helper_add(encoder, &radeon_atom_dig_helper_funcs);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_DAC1:
-               drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_DAC);
+               drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                DRM_MODE_ENCODER_DAC, NULL);
                radeon_encoder->enc_priv = radeon_atombios_set_dac_info(radeon_encoder);
                drm_encoder_helper_add(encoder, &radeon_atom_dac_helper_funcs);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_DAC2:
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1:
        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2:
-               drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_TVDAC);
+               drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                DRM_MODE_ENCODER_TVDAC, NULL);
                radeon_encoder->enc_priv = radeon_atombios_set_dac_info(radeon_encoder);
                drm_encoder_helper_add(encoder, &radeon_atom_dac_helper_funcs);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_UNIPHY3:
                if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
                        radeon_encoder->rmx_type = RMX_FULL;
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_LVDS);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                        radeon_encoder->enc_priv = radeon_atombios_get_lvds_info(radeon_encoder);
                } else if (radeon_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT)) {
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_DAC);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_DAC, NULL);
                        radeon_encoder->enc_priv = radeon_atombios_set_dig_info(radeon_encoder);
                } else {
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_TMDS);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                        radeon_encoder->enc_priv = radeon_atombios_set_dig_info(radeon_encoder);
                }
                drm_encoder_helper_add(encoder, &radeon_atom_dig_helper_funcs);
                /* these are handled by the primary encoders */
                radeon_encoder->is_ext_encoder = true;
                if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT))
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_LVDS);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_LVDS, NULL);
                else if (radeon_encoder->devices & (ATOM_DEVICE_CRT_SUPPORT))
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_DAC);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_DAC, NULL);
                else
-                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs, DRM_MODE_ENCODER_TMDS);
+                       drm_encoder_init(dev, encoder, &radeon_atom_enc_funcs,
+                                        DRM_MODE_ENCODER_TMDS, NULL);
                drm_encoder_helper_add(encoder, &radeon_atom_ext_helper_funcs);
                break;
        }
 
        }
 
        drm_encoder_init(dev, &radeon_encoder->base, &radeon_dp_mst_enc_funcs,
-                        DRM_MODE_ENCODER_DPMST);
+                        DRM_MODE_ENCODER_DPMST, NULL);
        drm_encoder_helper_add(encoder, &radeon_mst_helper_funcs);
 
        mst_enc = radeon_encoder->enc_priv;
 
        switch (radeon_encoder->encoder_id) {
        case ENCODER_OBJECT_ID_INTERNAL_LVDS:
                encoder->possible_crtcs = 0x1;
-               drm_encoder_init(dev, encoder, &radeon_legacy_lvds_enc_funcs, DRM_MODE_ENCODER_LVDS);
+               drm_encoder_init(dev, encoder, &radeon_legacy_lvds_enc_funcs,
+                                DRM_MODE_ENCODER_LVDS, NULL);
                drm_encoder_helper_add(encoder, &radeon_legacy_lvds_helper_funcs);
                if (rdev->is_atom_bios)
                        radeon_encoder->enc_priv = radeon_atombios_get_lvds_info(radeon_encoder);
                radeon_encoder->rmx_type = RMX_FULL;
                break;
        case ENCODER_OBJECT_ID_INTERNAL_TMDS1:
-               drm_encoder_init(dev, encoder, &radeon_legacy_tmds_int_enc_funcs, DRM_MODE_ENCODER_TMDS);
+               drm_encoder_init(dev, encoder, &radeon_legacy_tmds_int_enc_funcs,
+                                DRM_MODE_ENCODER_TMDS, NULL);
                drm_encoder_helper_add(encoder, &radeon_legacy_tmds_int_helper_funcs);
                radeon_encoder->enc_priv = radeon_legacy_get_tmds_info(radeon_encoder);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_DAC1:
-               drm_encoder_init(dev, encoder, &radeon_legacy_primary_dac_enc_funcs, DRM_MODE_ENCODER_DAC);
+               drm_encoder_init(dev, encoder, &radeon_legacy_primary_dac_enc_funcs,
+                                DRM_MODE_ENCODER_DAC, NULL);
                drm_encoder_helper_add(encoder, &radeon_legacy_primary_dac_helper_funcs);
                if (rdev->is_atom_bios)
                        radeon_encoder->enc_priv = radeon_atombios_get_primary_dac_info(radeon_encoder);
                        radeon_encoder->enc_priv = radeon_combios_get_primary_dac_info(radeon_encoder);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_DAC2:
-               drm_encoder_init(dev, encoder, &radeon_legacy_tv_dac_enc_funcs, DRM_MODE_ENCODER_TVDAC);
+               drm_encoder_init(dev, encoder, &radeon_legacy_tv_dac_enc_funcs,
+                                DRM_MODE_ENCODER_TVDAC, NULL);
                drm_encoder_helper_add(encoder, &radeon_legacy_tv_dac_helper_funcs);
                if (rdev->is_atom_bios)
                        radeon_encoder->enc_priv = radeon_atombios_get_tv_dac_info(radeon_encoder);
                        radeon_encoder->enc_priv = radeon_combios_get_tv_dac_info(radeon_encoder);
                break;
        case ENCODER_OBJECT_ID_INTERNAL_DVO1:
-               drm_encoder_init(dev, encoder, &radeon_legacy_tmds_ext_enc_funcs, DRM_MODE_ENCODER_TMDS);
+               drm_encoder_init(dev, encoder, &radeon_legacy_tmds_ext_enc_funcs,
+                                DRM_MODE_ENCODER_TMDS, NULL);
                drm_encoder_helper_add(encoder, &radeon_legacy_tmds_ext_helper_funcs);
                if (!rdev->is_atom_bios)
                        radeon_encoder->enc_priv = radeon_legacy_get_ext_tmds_info(radeon_encoder);
 
                        goto done;
        } else {
                ret = drm_encoder_init(rcdu->ddev, encoder, &encoder_funcs,
-                                      encoder_type);
+                                      encoder_type, NULL);
                if (ret < 0)
                        goto done;
 
 
                goto error;
 
        ret = drm_encoder_init(rcdu->ddev, encoder, &encoder_funcs,
-                              DRM_MODE_ENCODER_TMDS);
+                              DRM_MODE_ENCODER_TMDS, NULL);
        if (ret < 0)
                goto error;
 
 
 
        drm_encoder_helper_add(encoder, &dw_hdmi_rockchip_encoder_helper_funcs);
        drm_encoder_init(drm, encoder, &dw_hdmi_rockchip_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
 
        return dw_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data);
 }
 
        encoder->possible_crtcs = 1;
 
        ret = drm_encoder_init(sdev->ddev, encoder, &encoder_funcs,
-                              DRM_MODE_ENCODER_LVDS);
+                              DRM_MODE_ENCODER_LVDS, NULL);
        if (ret < 0)
                return ret;
 
 
        drm_encoder->possible_clones = 1 << 0;
 
        drm_encoder_init(dev, drm_encoder,
-                        &sti_tvout_encoder_funcs, DRM_MODE_ENCODER_LVDS);
+                        &sti_tvout_encoder_funcs, DRM_MODE_ENCODER_LVDS,
+                        NULL);
 
        drm_encoder_helper_add(drm_encoder, &sti_dvo_encoder_helper_funcs);
 
        drm_encoder->possible_clones = 1 << 0;
 
        drm_encoder_init(dev, drm_encoder,
-                       &sti_tvout_encoder_funcs, DRM_MODE_ENCODER_DAC);
+                       &sti_tvout_encoder_funcs, DRM_MODE_ENCODER_DAC, NULL);
 
        drm_encoder_helper_add(drm_encoder, &sti_hda_encoder_helper_funcs);
 
        drm_encoder->possible_clones = 1 << 1;
 
        drm_encoder_init(dev, drm_encoder,
-                       &sti_tvout_encoder_funcs, DRM_MODE_ENCODER_TMDS);
+                       &sti_tvout_encoder_funcs, DRM_MODE_ENCODER_TMDS, NULL);
 
        drm_encoder_helper_add(drm_encoder, &sti_hdmi_encoder_helper_funcs);
 
 
 
                drm_encoder_init(drm, &dsi->output.encoder,
                                 &tegra_dsi_encoder_funcs,
-                                DRM_MODE_ENCODER_DSI);
+                                DRM_MODE_ENCODER_DSI, NULL);
                drm_encoder_helper_add(&dsi->output.encoder,
                                       &tegra_dsi_encoder_helper_funcs);
 
 
        hdmi->output.connector.dpms = DRM_MODE_DPMS_OFF;
 
        drm_encoder_init(drm, &hdmi->output.encoder, &tegra_hdmi_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
        drm_encoder_helper_add(&hdmi->output.encoder,
                               &tegra_hdmi_encoder_helper_funcs);
 
 
        output->connector.dpms = DRM_MODE_DPMS_OFF;
 
        drm_encoder_init(drm, &output->encoder, &tegra_rgb_encoder_funcs,
-                        DRM_MODE_ENCODER_LVDS);
+                        DRM_MODE_ENCODER_LVDS, NULL);
        drm_encoder_helper_add(&output->encoder,
                               &tegra_rgb_encoder_helper_funcs);
 
 
        sor->output.connector.dpms = DRM_MODE_DPMS_OFF;
 
        drm_encoder_init(drm, &sor->output.encoder, &tegra_sor_encoder_funcs,
-                        encoder);
+                        encoder, NULL);
        drm_encoder_helper_add(&sor->output.encoder, helpers);
 
        drm_mode_connector_attach_encoder(&sor->output.connector,
 
        encoder->possible_crtcs = 1;
 
        ret = drm_encoder_init(dev, encoder, &panel_encoder_funcs,
-                       DRM_MODE_ENCODER_LVDS);
+                       DRM_MODE_ENCODER_LVDS, NULL);
        if (ret < 0)
                goto fail;
 
 
        encoder->possible_crtcs = 1;
 
        ret = drm_encoder_init(dev, encoder, &tfp410_encoder_funcs,
-                       DRM_MODE_ENCODER_TMDS);
+                       DRM_MODE_ENCODER_TMDS, NULL);
        if (ret < 0)
                goto fail;
 
 
        if (!encoder)
                return NULL;
 
-       drm_encoder_init(dev, encoder, &udl_enc_funcs, DRM_MODE_ENCODER_TMDS);
+       drm_encoder_init(dev, encoder, &udl_enc_funcs, DRM_MODE_ENCODER_TMDS,
+                        NULL);
        drm_encoder_helper_add(encoder, &udl_helper_funcs);
        encoder->possible_crtcs = 1;
        return encoder;
 
        WARN_ON_ONCE((HD_READ(VC4_HD_M_CTL) & VC4_HD_M_ENABLE) == 0);
 
        drm_encoder_init(drm, hdmi->encoder, &vc4_hdmi_encoder_funcs,
-                        DRM_MODE_ENCODER_TMDS);
+                        DRM_MODE_ENCODER_TMDS, NULL);
        drm_encoder_helper_add(hdmi->encoder, &vc4_hdmi_encoder_helper_funcs);
 
        hdmi->connector = vc4_hdmi_connector_init(drm, hdmi->encoder);
 
        drm_connector_helper_add(connector, &virtio_gpu_conn_helper_funcs);
 
        drm_encoder_init(dev, encoder, &virtio_gpu_enc_funcs,
-                        DRM_MODE_ENCODER_VIRTUAL);
+                        DRM_MODE_ENCODER_VIRTUAL, NULL);
        drm_encoder_helper_add(encoder, &virtio_gpu_enc_helper_funcs);
        encoder->possible_crtcs = 1 << index;
 
 
        connector->status = vmw_du_connector_detect(connector, true);
 
        drm_encoder_init(dev, encoder, &vmw_legacy_encoder_funcs,
-                        DRM_MODE_ENCODER_VIRTUAL);
+                        DRM_MODE_ENCODER_VIRTUAL, NULL);
        drm_mode_connector_attach_encoder(connector, encoder);
        encoder->possible_crtcs = (1 << unit);
        encoder->possible_clones = 0;
 
        connector->status = vmw_du_connector_detect(connector, true);
 
        drm_encoder_init(dev, encoder, &vmw_screen_object_encoder_funcs,
-                        DRM_MODE_ENCODER_VIRTUAL);
+                        DRM_MODE_ENCODER_VIRTUAL, NULL);
        drm_mode_connector_attach_encoder(connector, encoder);
        encoder->possible_crtcs = (1 << unit);
        encoder->possible_clones = 0;
 
        connector->status = vmw_du_connector_detect(connector, false);
 
        drm_encoder_init(dev, encoder, &vmw_stdu_encoder_funcs,
-                        DRM_MODE_ENCODER_VIRTUAL);
+                        DRM_MODE_ENCODER_VIRTUAL, NULL);
        drm_mode_connector_attach_encoder(connector, encoder);
        encoder->possible_crtcs = (1 << unit);
        encoder->possible_clones = 0;
 
 void drm_bridge_pre_enable(struct drm_bridge *bridge);
 void drm_bridge_enable(struct drm_bridge *bridge);
 
-extern int drm_encoder_init(struct drm_device *dev,
-                           struct drm_encoder *encoder,
-                           const struct drm_encoder_funcs *funcs,
-                           int encoder_type);
+extern __printf(5, 6)
+int drm_encoder_init(struct drm_device *dev,
+                    struct drm_encoder *encoder,
+                    const struct drm_encoder_funcs *funcs,
+                    int encoder_type, const char *name, ...);
 
 /**
  * drm_encoder_crtc_ok - can a given crtc drive a given encoder?