static struct drm_connector *intel_dp_add_mst_connector(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, const char *pathprop) { struct intel_dp *intel_dp = container_of(mgr, struct intel_dp, mst_mgr); struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); struct drm_device *dev = intel_dig_port->base.base.dev; struct intel_connector *intel_connector; struct drm_connector *connector; int i; intel_connector = intel_connector_alloc(); if (!intel_connector) return NULL; connector = &intel_connector->base; drm_connector_init(dev, connector, &intel_dp_mst_connector_funcs, DRM_MODE_CONNECTOR_DisplayPort); drm_connector_helper_add(connector, &intel_dp_mst_connector_helper_funcs); intel_connector->get_hw_state = intel_dp_mst_get_hw_state; intel_connector->mst_port = intel_dp; intel_connector->port = port; for (i = PIPE_A; i <= PIPE_C; i++) { drm_mode_connector_attach_encoder(&intel_connector->base, &intel_dp->mst_encoders[i]->base.base); } intel_dp_add_properties(intel_dp, connector); drm_object_attach_property(&connector->base, dev->mode_config.path_property, 0); drm_object_attach_property(&connector->base, dev->mode_config.tile_property, 0); drm_mode_connector_set_path_property(connector, pathprop); return connector; }
void intel_hdmi_init(struct drm_device *dev, int sdvox_reg) { struct drm_i915_private *dev_priv = dev->dev_private; struct drm_connector *connector; struct intel_output *intel_output; struct intel_hdmi_priv *hdmi_priv; intel_output = kcalloc(sizeof(struct intel_output) + sizeof(struct intel_hdmi_priv), 1, GFP_KERNEL); if (!intel_output) return; hdmi_priv = (struct intel_hdmi_priv *)(intel_output + 1); connector = &intel_output->base; drm_connector_init(dev, connector, &intel_hdmi_connector_funcs, DRM_MODE_CONNECTOR_DVID); drm_connector_helper_add(connector, &intel_hdmi_connector_helper_funcs); intel_output->type = INTEL_OUTPUT_HDMI; connector->interlace_allowed = 0; connector->doublescan_allowed = 0; /* Set up the DDC bus. */ if (sdvox_reg == SDVOB) intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "HDMIB"); else intel_output->ddc_bus = intel_i2c_create(dev, GPIOD, "HDMIC"); if (!intel_output->ddc_bus) goto err_connector; hdmi_priv->sdvox_reg = sdvox_reg; intel_output->dev_priv = hdmi_priv; drm_encoder_init(dev, &intel_output->enc, &intel_hdmi_enc_funcs, DRM_MODE_ENCODER_TMDS); drm_encoder_helper_add(&intel_output->enc, &intel_hdmi_helper_funcs); drm_mode_connector_attach_encoder(&intel_output->base, &intel_output->enc); drm_sysfs_connector_add(connector); /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written * 0xd. Failure to do so will result in spurious interrupts being * generated on the port when a cable is not attached. */ if (IS_G4X(dev) && !IS_GM45(dev)) { u32 temp = I915_READ(PEG_BAND_GAP_DATA); I915_WRITE(PEG_BAND_GAP_DATA, (temp & ~0xf) | 0xd); } return; err_connector: drm_connector_cleanup(connector); kfree(intel_output); return; }
static int dce_virtual_connector_encoder_init(struct amdgpu_device *adev, int index) { struct drm_encoder *encoder; struct drm_connector *connector; /* add a new encoder */ encoder = kzalloc(sizeof(struct drm_encoder), GFP_KERNEL); if (!encoder) return -ENOMEM; encoder->possible_crtcs = 1 << index; drm_encoder_init(adev->ddev, encoder, &dce_virtual_encoder_funcs, DRM_MODE_ENCODER_VIRTUAL, NULL); drm_encoder_helper_add(encoder, &dce_virtual_encoder_helper_funcs); connector = kzalloc(sizeof(struct drm_connector), GFP_KERNEL); if (!connector) { kfree(encoder); return -ENOMEM; } /* add a new connector */ drm_connector_init(adev->ddev, connector, &dce_virtual_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); drm_connector_helper_add(connector, &dce_virtual_connector_helper_funcs); connector->display_info.subpixel_order = SubPixelHorizontalRGB; connector->interlace_allowed = false; connector->doublescan_allowed = false; drm_connector_register(connector); /* link them */ drm_mode_connector_attach_encoder(connector, encoder); return 0; }
void cdv_intel_crt_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev) { struct psb_intel_connector *psb_intel_connector; struct psb_intel_encoder *psb_intel_encoder; struct drm_connector *connector; struct drm_encoder *encoder; u32 i2c_reg; psb_intel_encoder = kzalloc(sizeof(struct psb_intel_encoder), GFP_KERNEL); if (!psb_intel_encoder) return; psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), GFP_KERNEL); if (!psb_intel_connector) goto failed_connector; connector = &psb_intel_connector->base; drm_connector_init(dev, connector, &cdv_intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA); encoder = &psb_intel_encoder->base; drm_encoder_init(dev, encoder, &cdv_intel_crt_enc_funcs, DRM_MODE_ENCODER_DAC); psb_intel_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); i2c_reg = GPIOA; psb_intel_encoder->ddc_bus = psb_intel_i2c_create(dev, i2c_reg, "CRTDDC_A"); if (!psb_intel_encoder->ddc_bus) { dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration " "failed.\n"); goto failed_ddc; } psb_intel_encoder->type = INTEL_OUTPUT_ANALOG; connector->interlace_allowed = 0; connector->doublescan_allowed = 0; drm_encoder_helper_add(encoder, &cdv_intel_crt_helper_funcs); drm_connector_helper_add(connector, &cdv_intel_crt_connector_helper_funcs); drm_sysfs_connector_add(connector); return; failed_ddc: drm_encoder_cleanup(&psb_intel_encoder->base); drm_connector_cleanup(&psb_intel_connector->base); kfree(psb_intel_connector); failed_connector: kfree(psb_intel_encoder); return; }
/* initialize connector */ struct drm_connector *mdp4_lvds_connector_init(struct drm_device *dev, struct device_node *panel_node, struct drm_encoder *encoder) { struct drm_connector *connector = NULL; struct mdp4_lvds_connector *mdp4_lvds_connector; mdp4_lvds_connector = kzalloc(sizeof(*mdp4_lvds_connector), GFP_KERNEL); if (!mdp4_lvds_connector) return ERR_PTR(-ENOMEM); mdp4_lvds_connector->encoder = encoder; mdp4_lvds_connector->panel_node = panel_node; connector = &mdp4_lvds_connector->base; drm_connector_init(dev, connector, &mdp4_lvds_connector_funcs, DRM_MODE_CONNECTOR_LVDS); drm_connector_helper_add(connector, &mdp4_lvds_connector_helper_funcs); connector->polled = 0; connector->interlace_allowed = 0; connector->doublescan_allowed = 0; drm_connector_attach_encoder(connector, encoder); return connector; }
static struct drm_connector * hibmc_connector_init(struct hibmc_drm_private *priv) { struct drm_device *dev = priv->dev; struct drm_connector *connector; int ret; connector = devm_kzalloc(dev->dev, sizeof(*connector), GFP_KERNEL); if (!connector) { DRM_ERROR("failed to alloc memory when init connector\n"); return ERR_PTR(-ENOMEM); } ret = drm_connector_init(dev, connector, &hibmc_connector_funcs, DRM_MODE_CONNECTOR_VGA); if (ret) { DRM_ERROR("failed to init connector: %d\n", ret); return ERR_PTR(ret); } drm_connector_helper_add(connector, &hibmc_connector_helper_funcs); return connector; }
static int imx_pd_register(struct drm_device *drm, struct imx_parallel_display *imxpd) { int ret; ret = imx_drm_encoder_parse_of(drm, &imxpd->encoder, imxpd->dev->of_node); if (ret) return ret; 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_connector_helper_add(&imxpd->connector, &imx_pd_connector_helper_funcs); drm_connector_init(drm, &imxpd->connector, &imx_pd_connector_funcs, DRM_MODE_CONNECTOR_VGA); if (imxpd->panel) drm_panel_attach(imxpd->panel, &imxpd->connector); drm_mode_connector_attach_encoder(&imxpd->connector, &imxpd->encoder); imxpd->connector.encoder = &imxpd->encoder; return 0; }
static int imx_hdmi_register(struct drm_device *drm, struct imx_hdmi *hdmi) { int ret; ret = imx_drm_encoder_parse_of(drm, &hdmi->encoder, hdmi->dev->of_node); if (ret) return ret; hdmi->connector.polled = DRM_CONNECTOR_POLL_HPD; drm_encoder_helper_add(&hdmi->encoder, &imx_hdmi_encoder_helper_funcs); drm_encoder_init(drm, &hdmi->encoder, &imx_hdmi_encoder_funcs, DRM_MODE_ENCODER_TMDS); drm_connector_helper_add(&hdmi->connector, &imx_hdmi_connector_helper_funcs); drm_connector_init(drm, &hdmi->connector, &imx_hdmi_connector_funcs, DRM_MODE_CONNECTOR_HDMIA); hdmi->connector.encoder = &hdmi->encoder; drm_mode_connector_attach_encoder(&hdmi->connector, &hdmi->encoder); return 0; }
static int imx_pd_register(struct drm_device *drm, struct imx_parallel_display *imxpd) { int ret; ret = imx_drm_encoder_parse_of(drm, &imxpd->encoder, imxpd->dev->of_node); if (ret) return ret; /* set the connector's dpms to OFF so that * drm_helper_connector_dpms() won't return * immediately since the current state is ON * at this point. */ imxpd->connector.dpms = DRM_MODE_DPMS_OFF; 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, NULL); drm_connector_helper_add(&imxpd->connector, &imx_pd_connector_helper_funcs); drm_connector_init(drm, &imxpd->connector, &imx_pd_connector_funcs, DRM_MODE_CONNECTOR_VGA); if (imxpd->panel) drm_panel_attach(imxpd->panel, &imxpd->connector); drm_mode_connector_attach_encoder(&imxpd->connector, &imxpd->encoder); return 0; }
static int exynos_dp_create_connector(struct exynos_drm_display *display, struct drm_encoder *encoder) { struct exynos_dp_device *dp = display_to_dp(display); struct drm_connector *connector = &dp->connector; int ret; dp->encoder = encoder; /* Pre-empt DP connector creation if there's a bridge */ ret = exynos_drm_attach_lcd_bridge(dp->drm_dev, encoder); if (ret) return 0; connector->polled = DRM_CONNECTOR_POLL_HPD; ret = drm_connector_init(dp->drm_dev, connector, &exynos_dp_connector_funcs, DRM_MODE_CONNECTOR_eDP); if (ret) { DRM_ERROR("Failed to initialize connector with drm\n"); return ret; } drm_connector_helper_add(connector, &exynos_dp_connector_helper_funcs); drm_connector_register(connector); drm_mode_connector_attach_encoder(connector, encoder); if (dp->panel) ret = drm_panel_attach(dp->panel, &dp->connector); return ret; }
/* initialize connector */ struct drm_connector *msm_edp_connector_init(struct msm_edp *edp) { struct drm_connector *connector = NULL; struct edp_connector *edp_connector; int ret; edp_connector = kzalloc(sizeof(*edp_connector), GFP_KERNEL); if (!edp_connector) return ERR_PTR(-ENOMEM); edp_connector->edp = edp; connector = &edp_connector->base; ret = drm_connector_init(edp->dev, connector, &edp_connector_funcs, DRM_MODE_CONNECTOR_eDP); if (ret) return ERR_PTR(ret); drm_connector_helper_add(connector, &edp_connector_helper_funcs); /* We don't support HPD, so only poll status until connected. */ connector->polled = DRM_CONNECTOR_POLL_CONNECT; /* Display driver doesn't support interlace now. */ connector->interlace_allowed = false; connector->doublescan_allowed = false; drm_mode_connector_attach_encoder(connector, edp->encoder); return connector; }
static int qdev_output_init(struct drm_device *dev, int num_output) { struct qxl_device *qdev = dev->dev_private; struct qxl_output *qxl_output; struct drm_connector *connector; struct drm_encoder *encoder; qxl_output = kzalloc(sizeof(struct qxl_output), GFP_KERNEL); if (!qxl_output) return -ENOMEM; qxl_output->index = num_output; connector = &qxl_output->base; encoder = &qxl_output->enc; drm_connector_init(dev, &qxl_output->base, &qxl_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); drm_encoder_init(dev, &qxl_output->enc, &qxl_enc_funcs, DRM_MODE_ENCODER_VIRTUAL); /* we get HPD via client monitors config */ connector->polled = DRM_CONNECTOR_POLL_HPD; encoder->possible_crtcs = 1 << num_output; drm_mode_connector_attach_encoder(&qxl_output->base, &qxl_output->enc); drm_encoder_helper_add(encoder, &qxl_enc_helper_funcs); drm_connector_helper_add(connector, &qxl_connector_helper_funcs); drm_object_attach_property(&connector->base, qdev->hotplug_mode_update_property, 0); drm_sysfs_connector_add(connector); return 0; }
struct drm_connector *exynos_drm_connector_create(struct drm_device *dev, struct drm_encoder *encoder) { struct exynos_drm_connector *exynos_connector; struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder); struct drm_connector *connector; int type; int err; exynos_connector = kzalloc(sizeof(*exynos_connector), GFP_KERNEL); if (!exynos_connector) return NULL; connector = &exynos_connector->drm_connector; switch (manager->display_ops->type) { case EXYNOS_DISPLAY_TYPE_HDMI: type = DRM_MODE_CONNECTOR_HDMIA; connector->interlace_allowed = true; connector->polled = DRM_CONNECTOR_POLL_HPD; break; case EXYNOS_DISPLAY_TYPE_VIDI: type = DRM_MODE_CONNECTOR_VIRTUAL; connector->polled = DRM_CONNECTOR_POLL_HPD; break; default: type = DRM_MODE_CONNECTOR_Unknown; break; } drm_connector_init(dev, connector, &exynos_connector_funcs, type); drm_connector_helper_add(connector, &exynos_connector_helper_funcs); err = drm_sysfs_connector_add(connector); if (err) goto err_connector; exynos_connector->encoder_id = encoder->base.id; exynos_connector->manager = manager; exynos_connector->dpms = DRM_MODE_DPMS_OFF; connector->dpms = DRM_MODE_DPMS_OFF; connector->encoder = encoder; err = drm_mode_connector_attach_encoder(connector, encoder); if (err) { DRM_ERROR("failed to attach a connector to a encoder\n"); goto err_sysfs; } DRM_DEBUG_KMS("connector has been created\n"); return connector; err_sysfs: drm_sysfs_connector_remove(connector); err_connector: drm_connector_cleanup(connector); kfree(exynos_connector); return NULL; }
static int rcar_lvds_attach(struct drm_bridge *bridge) { struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge); struct drm_connector *connector = &lvds->connector; struct drm_encoder *encoder = bridge->encoder; int ret; /* If we have a next bridge just attach it. */ if (lvds->next_bridge) return drm_bridge_attach(bridge->encoder, lvds->next_bridge, bridge); /* Otherwise we have a panel, create a connector. */ ret = drm_connector_init(bridge->dev, connector, &rcar_lvds_conn_funcs, DRM_MODE_CONNECTOR_LVDS); if (ret < 0) return ret; drm_connector_helper_add(connector, &rcar_lvds_conn_helper_funcs); ret = drm_mode_connector_attach_encoder(connector, encoder); if (ret < 0) return ret; return drm_panel_attach(lvds->panel, connector); }
static int dw_hdmi_register(struct drm_device *drm, struct dw_hdmi *hdmi) { struct drm_encoder *encoder = hdmi->encoder; struct drm_bridge *bridge; int ret; bridge = devm_kzalloc(drm->dev, sizeof(*bridge), GFP_KERNEL); if (!bridge) { DRM_ERROR("Failed to allocate drm bridge\n"); return -ENOMEM; } hdmi->bridge = bridge; bridge->driver_private = hdmi; bridge->funcs = &dw_hdmi_bridge_funcs; ret = drm_bridge_attach(drm, bridge); if (ret) { DRM_ERROR("Failed to initialize bridge with drm\n"); return -EINVAL; } encoder->bridge = bridge; hdmi->connector.polled = DRM_CONNECTOR_POLL_HPD; drm_connector_helper_add(&hdmi->connector, &dw_hdmi_connector_helper_funcs); drm_connector_init(drm, &hdmi->connector, &dw_hdmi_connector_funcs, DRM_MODE_CONNECTOR_HDMIA); hdmi->connector.encoder = encoder; drm_mode_connector_attach_encoder(&hdmi->connector, encoder); return 0; }
/* initialize connector when we're connected to a drm_panel */ struct drm_connector *msm_dsi_manager_connector_init(u8 id) { struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id); struct drm_connector *connector = NULL; struct dsi_connector *dsi_connector; int ret; dsi_connector = kzalloc(sizeof(*dsi_connector), GFP_KERNEL); if (!dsi_connector) return ERR_PTR(-ENOMEM); dsi_connector->id = id; connector = &dsi_connector->base; ret = drm_connector_init(msm_dsi->dev, connector, &dsi_mgr_connector_funcs, DRM_MODE_CONNECTOR_DSI); if (ret) return ERR_PTR(ret); drm_connector_helper_add(connector, &dsi_mgr_conn_helper_funcs); /* Enable HPD to let hpd event is handled * when panel is attached to the host. */ connector->polled = DRM_CONNECTOR_POLL_HPD; /* Display driver doesn't support interlace now. */ connector->interlace_allowed = 0; connector->doublescan_allowed = 0; drm_connector_attach_encoder(connector, msm_dsi->encoder); return connector; }
static int exynos_dp_bridge_attach(struct drm_bridge *bridge) { struct exynos_dp_device *dp = bridge->driver_private; struct drm_encoder *encoder = &dp->encoder; struct drm_connector *connector = &dp->connector; int ret; /* Pre-empt DP connector creation if there's a bridge */ if (dp->ptn_bridge) { ret = exynos_drm_attach_lcd_bridge(dp, encoder); if (!ret) return 0; } connector->polled = DRM_CONNECTOR_POLL_HPD; ret = drm_connector_init(dp->drm_dev, connector, &exynos_dp_connector_funcs, DRM_MODE_CONNECTOR_eDP); if (ret) { DRM_ERROR("Failed to initialize connector with drm\n"); return ret; } drm_connector_helper_add(connector, &exynos_dp_connector_helper_funcs); drm_connector_register(connector); drm_mode_connector_attach_encoder(connector, encoder); if (dp->panel) ret = drm_panel_attach(dp->panel, &dp->connector); return ret; }
/* initialize connector */ struct drm_connector *msm_hdmi_connector_init(struct hdmi *hdmi) { struct drm_connector *connector = NULL; struct hdmi_connector *hdmi_connector; hdmi_connector = kzalloc(sizeof(*hdmi_connector), GFP_KERNEL); if (!hdmi_connector) return ERR_PTR(-ENOMEM); hdmi_connector->hdmi = hdmi; INIT_WORK(&hdmi_connector->hpd_work, msm_hdmi_hotplug_work); connector = &hdmi_connector->base; drm_connector_init(hdmi->dev, connector, &hdmi_connector_funcs, DRM_MODE_CONNECTOR_HDMIA); drm_connector_helper_add(connector, &msm_hdmi_connector_helper_funcs); connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT; connector->interlace_allowed = 0; connector->doublescan_allowed = 0; drm_connector_attach_encoder(connector, hdmi->encoder); return connector; }
static int exynos_dpi_create_connector(struct exynos_drm_display *display, struct drm_encoder *encoder) { struct exynos_dpi *ctx = display->ctx; struct drm_connector *connector = &ctx->connector; int ret; ctx->encoder = encoder; if (ctx->panel_node) connector->polled = DRM_CONNECTOR_POLL_CONNECT; else connector->polled = DRM_CONNECTOR_POLL_HPD; ret = drm_connector_init(encoder->dev, connector, &exynos_dpi_connector_funcs, DRM_MODE_CONNECTOR_VGA); if (ret) { DRM_ERROR("failed to initialize connector with drm\n"); return ret; } drm_connector_helper_add(connector, &exynos_dpi_connector_helper_funcs); drm_sysfs_connector_add(connector); drm_mode_connector_attach_encoder(connector, encoder); return 0; }
static int vmw_sou_init(struct vmw_private *dev_priv, unsigned unit) { struct vmw_screen_object_unit *sou; struct drm_device *dev = dev_priv->dev; struct drm_connector *connector; struct drm_encoder *encoder; struct drm_crtc *crtc; sou = kzalloc(sizeof(*sou), GFP_KERNEL); if (!sou) return -ENOMEM; sou->base.unit = unit; crtc = &sou->base.crtc; encoder = &sou->base.encoder; connector = &sou->base.connector; sou->base.active_implicit = false; sou->base.pref_active = (unit == 0); sou->base.pref_width = dev_priv->initial_width; sou->base.pref_height = dev_priv->initial_height; sou->base.pref_mode = NULL; sou->base.is_implicit = false; drm_connector_init(dev, connector, &vmw_sou_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); connector->status = vmw_du_connector_detect(connector, true); drm_encoder_init(dev, encoder, &vmw_screen_object_encoder_funcs, DRM_MODE_ENCODER_VIRTUAL, NULL); drm_mode_connector_attach_encoder(connector, encoder); encoder->possible_crtcs = (1 << unit); encoder->possible_clones = 0; (void) drm_connector_register(connector); drm_crtc_init(dev, crtc, &vmw_screen_object_crtc_funcs); drm_mode_crtc_set_gamma_size(crtc, 256); drm_object_attach_property(&connector->base, dev->mode_config.dirty_info_property, 1); drm_object_attach_property(&connector->base, dev_priv->hotplug_mode_update_property, 1); drm_object_attach_property(&connector->base, dev->mode_config.suggested_x_property, 0); drm_object_attach_property(&connector->base, dev->mode_config.suggested_y_property, 0); if (dev_priv->implicit_placement_property) drm_object_attach_property (&connector->base, dev_priv->implicit_placement_property, sou->base.is_implicit); return 0; }
int tegra_output_init(struct drm_device *drm, struct tegra_output *output) { int connector, encoder; switch (output->type) { case TEGRA_OUTPUT_RGB: connector = DRM_MODE_CONNECTOR_LVDS; encoder = DRM_MODE_ENCODER_LVDS; break; case TEGRA_OUTPUT_HDMI: connector = DRM_MODE_CONNECTOR_HDMIA; encoder = DRM_MODE_ENCODER_TMDS; break; case TEGRA_OUTPUT_DSI: connector = DRM_MODE_CONNECTOR_DSI; encoder = DRM_MODE_ENCODER_DSI; break; case TEGRA_OUTPUT_EDP: connector = DRM_MODE_CONNECTOR_eDP; encoder = DRM_MODE_ENCODER_TMDS; break; default: connector = DRM_MODE_CONNECTOR_Unknown; encoder = DRM_MODE_ENCODER_NONE; break; } drm_connector_init(drm, &output->connector, &connector_funcs, connector); drm_connector_helper_add(&output->connector, &connector_helper_funcs); output->connector.dpms = DRM_MODE_DPMS_OFF; if (output->panel) drm_panel_attach(output->panel, &output->connector); drm_encoder_init(drm, &output->encoder, &encoder_funcs, encoder); drm_encoder_helper_add(&output->encoder, &encoder_helper_funcs); drm_mode_connector_attach_encoder(&output->connector, &output->encoder); drm_connector_register(&output->connector); output->encoder.possible_crtcs = 0x3; /* * The connector is now registered and ready to receive hotplug events * so the hotplug interrupt can be enabled. */ if (gpio_is_valid(output->hpd_gpio)) enable_irq(output->hpd_irq); return 0; }
static struct drm_connector *intel_dp_add_mst_connector(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, const char *pathprop) { struct intel_dp *intel_dp = container_of(mgr, struct intel_dp, mst_mgr); struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); struct drm_device *dev = intel_dig_port->base.base.dev; struct drm_i915_private *dev_priv = to_i915(dev); struct intel_connector *intel_connector; struct drm_connector *connector; enum pipe pipe; int ret; intel_connector = intel_connector_alloc(); if (!intel_connector) return NULL; intel_connector->get_hw_state = intel_dp_mst_get_hw_state; intel_connector->mst_port = intel_dp; intel_connector->port = port; drm_dp_mst_get_port_malloc(port); connector = &intel_connector->base; ret = drm_connector_init(dev, connector, &intel_dp_mst_connector_funcs, DRM_MODE_CONNECTOR_DisplayPort); if (ret) { intel_connector_free(intel_connector); return NULL; } drm_connector_helper_add(connector, &intel_dp_mst_connector_helper_funcs); for_each_pipe(dev_priv, pipe) { struct drm_encoder *enc = &intel_dp->mst_encoders[pipe]->base.base; ret = drm_connector_attach_encoder(&intel_connector->base, enc); if (ret) goto err; } drm_object_attach_property(&connector->base, dev->mode_config.path_property, 0); drm_object_attach_property(&connector->base, dev->mode_config.tile_property, 0); ret = drm_connector_set_path_property(connector, pathprop); if (ret) goto err; intel_attach_force_audio_property(connector); intel_attach_broadcast_rgb_property(connector); drm_connector_attach_max_bpc_property(connector, 6, 12); return connector; err: drm_connector_cleanup(connector); return NULL; }
static void bochs_connector_init(struct drm_device *dev) { struct bochs_device *bochs = dev->dev_private; struct drm_connector *connector = &bochs->connector; drm_connector_init(dev, connector, &bochs_connector_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); drm_connector_helper_add(connector, &bochs_connector_connector_helper_funcs); drm_connector_register(connector); }
int arcpgu_drm_sim_init(struct drm_device *drm, struct device_node *np) { struct arcpgu_drm_connector *arcpgu_connector; struct drm_encoder *encoder; struct drm_connector *connector; int ret; encoder = devm_kzalloc(drm->dev, sizeof(*encoder), GFP_KERNEL); if (encoder == NULL) return -ENOMEM; encoder->possible_crtcs = 1; encoder->possible_clones = 0; ret = drm_encoder_init(drm, encoder, &arcpgu_drm_encoder_funcs, DRM_MODE_ENCODER_VIRTUAL, NULL); if (ret) return ret; arcpgu_connector = devm_kzalloc(drm->dev, sizeof(*arcpgu_connector), GFP_KERNEL); if (!arcpgu_connector) { ret = -ENOMEM; goto error_encoder_cleanup; } connector = &arcpgu_connector->connector; drm_connector_helper_add(connector, &arcpgu_drm_connector_helper_funcs); ret = drm_connector_init(drm, connector, &arcpgu_drm_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); if (ret < 0) { dev_err(drm->dev, "failed to initialize drm connector\n"); goto error_encoder_cleanup; } ret = drm_connector_attach_encoder(connector, encoder); if (ret < 0) { dev_err(drm->dev, "could not attach connector to encoder\n"); drm_connector_unregister(connector); goto error_connector_cleanup; } return 0; error_connector_cleanup: drm_connector_cleanup(connector); error_encoder_cleanup: drm_encoder_cleanup(encoder); return ret; }
int rcar_du_lvds_connector_init(struct rcar_du_device *rcdu, struct rcar_du_encoder *renc, /* TODO const */ struct device_node *np) { struct drm_encoder *encoder = rcar_encoder_to_drm_encoder(renc); struct rcar_du_lvds_connector *lvdscon; struct drm_connector *connector; struct display_timing timing; int ret; lvdscon = devm_kzalloc(rcdu->dev, sizeof(*lvdscon), GFP_KERNEL); if (lvdscon == NULL) return -ENOMEM; ret = of_get_display_timing(np, "panel-timing", &timing); if (ret < 0) return ret; videomode_from_timing(&timing, &lvdscon->panel.mode); of_property_read_u32(np, "width-mm", &lvdscon->panel.width_mm); of_property_read_u32(np, "height-mm", &lvdscon->panel.height_mm); connector = &lvdscon->connector.connector; connector->display_info.width_mm = lvdscon->panel.width_mm; connector->display_info.height_mm = lvdscon->panel.height_mm; ret = drm_connector_init(rcdu->ddev, connector, &connector_funcs, DRM_MODE_CONNECTOR_LVDS); if (ret < 0) return ret; drm_connector_helper_add(connector, &connector_helper_funcs); ret = drm_connector_register(connector); if (ret < 0) return ret; drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF); drm_object_property_set_value(&connector->base, rcdu->ddev->mode_config.dpms_property, DRM_MODE_DPMS_OFF); ret = drm_mode_connector_attach_encoder(connector, encoder); if (ret < 0) return ret; connector->encoder = encoder; lvdscon->connector.encoder = renc; return 0; }
static int analogix_dp_bridge_attach(struct drm_bridge *bridge) { struct analogix_dp_device *dp = bridge->driver_private; struct drm_encoder *encoder = dp->encoder; struct drm_connector *connector = &dp->connector; int ret; if (!bridge->encoder) { DRM_ERROR("Parent encoder object not found"); return -ENODEV; } connector->polled = DRM_CONNECTOR_POLL_HPD; ret = drm_connector_init(dp->drm_dev, connector, &analogix_dp_connector_funcs, DRM_MODE_CONNECTOR_eDP); if (ret) { DRM_ERROR("Failed to initialize connector with drm\n"); return ret; } drm_connector_helper_add(connector, &analogix_dp_connector_helper_funcs); drm_mode_connector_attach_encoder(connector, encoder); /* * NOTE: the connector registration is implemented in analogix * platform driver, that to say connector would be exist after * plat_data->attch return, that's why we record the connector * point after plat attached. */ if (dp->plat_data->attach) { ret = dp->plat_data->attach(dp->plat_data, bridge, connector); if (ret) { DRM_ERROR("Failed at platform attch func\n"); return ret; } } if (dp->plat_data->panel) { ret = drm_panel_attach(dp->plat_data->panel, &dp->connector); if (ret) { DRM_ERROR("Failed to attach panel\n"); return ret; } } return 0; }
int vbox_connector_init(struct drm_device *pDev, unsigned cScreen, struct drm_encoder *pEncoder) { struct vbox_connector *pVBoxConnector; struct drm_connector *pConnector; int rc; LogFunc(("vboxvideo: %d: pDev=%p, pEncoder=%p\n", __LINE__, pDev, pEncoder)); pVBoxConnector = kzalloc(sizeof(struct vbox_connector), GFP_KERNEL); if (!pVBoxConnector) return -ENOMEM; pConnector = &pVBoxConnector->base; /* * Set up the sysfs file we use for getting video mode hints from user * space. */ snprintf(pVBoxConnector->szName, sizeof(pVBoxConnector->szName), "vbox_screen_%u", cScreen); pVBoxConnector->deviceAttribute.attr.name = pVBoxConnector->szName; pVBoxConnector->deviceAttribute.attr.mode = S_IWUSR; pVBoxConnector->deviceAttribute.show = NULL; pVBoxConnector->deviceAttribute.store = vbox_connector_write_sysfs; rc = device_create_file(pDev->dev, &pVBoxConnector->deviceAttribute); if (rc < 0) { kfree(pVBoxConnector); return rc; } drm_connector_init(pDev, pConnector, &vbox_connector_funcs, DRM_MODE_CONNECTOR_VGA); drm_connector_helper_add(pConnector, &vbox_connector_helper_funcs); pConnector->interlace_allowed = 0; pConnector->doublescan_allowed = 0; drm_sysfs_connector_add(pConnector); /* The connector supports hot-plug detection: we promise to call * "drm_helper_hpd_irq_event" when hot-plugging occurs. */ pConnector->polled = DRM_CONNECTOR_POLL_HPD; drm_mode_connector_attach_encoder(pConnector, pEncoder); LogFunc(("vboxvideo: %d: pConnector=%p\n", __LINE__, pConnector)); return 0; }
int udl_connector_init(struct drm_device *dev, struct drm_encoder *encoder) { struct drm_connector *connector; connector = kzalloc(sizeof(struct drm_connector), GFP_KERNEL); if (!connector) return -ENOMEM; drm_connector_init(dev, connector, &udl_connector_funcs, DRM_MODE_CONNECTOR_DVII); drm_connector_helper_add(connector, &udl_connector_helper_funcs); drm_connector_register(connector); drm_mode_connector_attach_encoder(connector, encoder); return 0; }
static PVRPSB_CONNECTOR *CRTConnectorCreate(PVRPSB_DEVINFO *psDevInfo, struct i2c_adapter *psAdapter) { PVRPSB_CONNECTOR *psPVRConnector; psPVRConnector = (PVRPSB_CONNECTOR *)kzalloc(sizeof(PVRPSB_CONNECTOR), GFP_KERNEL); if (psPVRConnector) { drm_connector_init(psDevInfo->psDrmDev, &psPVRConnector->sConnector, &sCRTConnectorFuncs, DRM_MODE_CONNECTOR_VGA); drm_connector_helper_add(&psPVRConnector->sConnector, &sCRTConnectorHelperFuncs); psPVRConnector->psAdapter = psAdapter; psPVRConnector->ePort = PSB_PORT_ANALOG; } return psPVRConnector; }
int pl111_connector_init(struct drm_device *dev) { struct pl111_drm_dev_private *priv = dev->dev_private; struct pl111_drm_connector *pl111_connector = &priv->connector; struct drm_connector *connector = &pl111_connector->connector; drm_connector_init(dev, connector, &connector_funcs, DRM_MODE_CONNECTOR_DPI); drm_connector_helper_add(connector, &connector_helper_funcs); pl111_connector->panel = pl111_get_panel(dev->dev); if (pl111_connector->panel) drm_panel_attach(pl111_connector->panel, connector); return 0; }