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; }
static int exynos_dp_bridge_attach(struct analogix_dp_plat_data *plat_data, struct drm_bridge *bridge, struct drm_connector *connector) { struct exynos_dp_device *dp = to_dp(plat_data); struct drm_encoder *encoder = &dp->encoder; int ret; drm_connector_register(connector); dp->connector = connector; /* Pre-empt DP connector creation if there's a bridge */ if (dp->ptn_bridge) { bridge->next = dp->ptn_bridge; dp->ptn_bridge->encoder = encoder; ret = drm_bridge_attach(encoder->dev, dp->ptn_bridge); if (ret) { DRM_ERROR("Failed to attach bridge to drm\n"); bridge->next = NULL; return ret; } } return 0; }
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; }
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; }
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_connector_register(connector); return 0; }
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; 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_connector_register(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 void intel_dp_register_mst_connector(struct drm_connector *connector) { struct drm_i915_private *dev_priv = to_i915(connector->dev); if (dev_priv->fbdev) drm_fb_helper_add_one_connector(&dev_priv->fbdev->helper, connector); drm_connector_register(connector); }
static void intel_dp_register_mst_connector(struct drm_connector *connector) { struct intel_connector *intel_connector = to_intel_connector(connector); struct drm_device *dev = connector->dev; drm_modeset_lock_all(dev); intel_connector_add_to_fbdev(intel_connector); drm_modeset_unlock_all(dev); drm_connector_register(&intel_connector->base); }
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); }
static int kirin_drm_connectors_register(struct drm_device *dev) { struct drm_connector *connector; struct drm_connector *failed_connector; int ret; mutex_lock(&dev->mode_config.mutex); drm_for_each_connector(connector, dev) { ret = drm_connector_register(connector); if (ret) { failed_connector = connector; goto err; } }
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; }
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; }
/* initialize connector */ struct drm_connector *hdmi_connector_init(struct hdmi *hdmi) { struct drm_connector *connector = NULL; struct hdmi_connector *hdmi_connector; int ret; hdmi_connector = kzalloc(sizeof(*hdmi_connector), GFP_KERNEL); if (!hdmi_connector) { ret = -ENOMEM; goto fail; } hdmi_connector->hdmi = hdmi; INIT_WORK(&hdmi_connector->hpd_work, hotplug_work); connector = &hdmi_connector->base; drm_connector_init(hdmi->dev, connector, &hdmi_connector_funcs, DRM_MODE_CONNECTOR_HDMIA); drm_connector_helper_add(connector, &hdmi_connector_helper_funcs); connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT; connector->interlace_allowed = 1; connector->doublescan_allowed = 0; drm_connector_register(connector); ret = hpd_enable(hdmi_connector); if (ret) { dev_err(hdmi->dev->dev, "failed to enable HPD: %d\n", ret); goto fail; } drm_mode_connector_attach_encoder(connector, hdmi->encoder); return connector; fail: if (connector) hdmi_connector_destroy(connector); return ERR_PTR(ret); }
/* initialize connector */ struct drm_connector *omap_connector_init(struct drm_device *dev, int connector_type, struct omap_dss_device *dssdev, struct drm_encoder *encoder) { struct drm_connector *connector = NULL; struct omap_connector *omap_connector; DBG("%s", dssdev->name); omap_dss_get_device(dssdev); omap_connector = kzalloc(sizeof(struct omap_connector), GFP_KERNEL); if (!omap_connector) goto fail; omap_connector->dssdev = dssdev; omap_connector->encoder = encoder; connector = &omap_connector->base; drm_connector_init(dev, connector, &omap_connector_funcs, connector_type); drm_connector_helper_add(connector, &omap_connector_helper_funcs); #if 0 /* enable when dss2 supports hotplug */ if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_HPD) connector->polled = 0; else #endif connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT; connector->interlace_allowed = 1; connector->doublescan_allowed = 0; drm_connector_register(connector); return connector; fail: if (connector) omap_connector_destroy(connector); return NULL; }
/* 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) { ret = -ENOMEM; goto fail; } edp_connector->edp = edp; connector = &edp_connector->base; ret = drm_connector_init(edp->dev, connector, &edp_connector_funcs, DRM_MODE_CONNECTOR_eDP); if (ret) goto fail; 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; ret = drm_connector_register(connector); if (ret) goto fail; drm_mode_connector_attach_encoder(connector, edp->encoder); return connector; fail: if (connector) edp_connector_destroy(connector); return ERR_PTR(ret); }
int shmob_drm_connector_create(struct shmob_drm_device *sdev, struct drm_encoder *encoder) { struct drm_connector *connector = &sdev->connector.connector; int ret; sdev->connector.encoder = encoder; connector->display_info.width_mm = sdev->pdata->panel.width_mm; connector->display_info.height_mm = sdev->pdata->panel.height_mm; ret = drm_connector_init(sdev->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) goto err_cleanup; ret = shmob_drm_backlight_init(&sdev->connector); if (ret < 0) goto err_sysfs; ret = drm_mode_connector_attach_encoder(connector, encoder); if (ret < 0) goto err_backlight; drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF); drm_object_property_set_value(&connector->base, sdev->ddev->mode_config.dpms_property, DRM_MODE_DPMS_OFF); return 0; err_backlight: shmob_drm_backlight_exit(&sdev->connector); err_sysfs: drm_connector_unregister(connector); err_cleanup: drm_connector_cleanup(connector); return ret; }
static struct drm_connector *cirrus_vga_init(struct drm_device *dev) { struct drm_connector *connector; struct cirrus_connector *cirrus_connector; cirrus_connector = kzalloc(sizeof(struct cirrus_connector), GFP_KERNEL); if (!cirrus_connector) return NULL; connector = &cirrus_connector->base; drm_connector_init(dev, connector, &cirrus_vga_connector_funcs, DRM_MODE_CONNECTOR_VGA); drm_connector_helper_add(connector, &cirrus_vga_connector_helper_funcs); drm_connector_register(connector); return connector; }
static int fsl_dcu_attach_panel(struct fsl_dcu_drm_device *fsl_dev, struct drm_panel *panel) { struct drm_encoder *encoder = &fsl_dev->encoder; struct drm_connector *connector = &fsl_dev->connector.base; struct drm_mode_config *mode_config = &fsl_dev->drm->mode_config; int ret; fsl_dev->connector.encoder = encoder; ret = drm_connector_init(fsl_dev->drm, connector, &fsl_dcu_drm_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) goto err_cleanup; ret = drm_mode_connector_attach_encoder(connector, encoder); if (ret < 0) goto err_sysfs; drm_object_property_set_value(&connector->base, mode_config->dpms_property, DRM_MODE_DPMS_OFF); ret = drm_panel_attach(panel, connector); if (ret) { dev_err(fsl_dev->dev, "failed to attach panel\n"); goto err_sysfs; } return 0; err_sysfs: drm_connector_unregister(connector); err_cleanup: drm_connector_cleanup(connector); return ret; }
/* initialize connector */ struct drm_connector *mdp4_lvds_connector_init(struct drm_device *dev, struct drm_panel *panel, struct drm_encoder *encoder) { struct drm_connector *connector = NULL; struct mdp4_lvds_connector *mdp4_lvds_connector; int ret; mdp4_lvds_connector = kzalloc(sizeof(*mdp4_lvds_connector), GFP_KERNEL); if (!mdp4_lvds_connector) { ret = -ENOMEM; goto fail; } mdp4_lvds_connector->encoder = encoder; mdp4_lvds_connector->panel = panel; 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_register(connector); drm_mode_connector_attach_encoder(connector, encoder); if (panel) drm_panel_attach(panel, connector); return connector; fail: if (connector) mdp4_lvds_connector_destroy(connector); return ERR_PTR(ret); }
static int vgdev_output_init(struct virtio_gpu_device *vgdev, int index) { struct drm_device *dev = vgdev->ddev; struct virtio_gpu_output *output = vgdev->outputs + index; struct drm_connector *connector = &output->conn; struct drm_encoder *encoder = &output->enc; struct drm_crtc *crtc = &output->crtc; struct drm_plane *primary, *cursor; output->index = index; if (index == 0) { output->info.enabled = cpu_to_le32(true); output->info.r.width = cpu_to_le32(XRES_DEF); output->info.r.height = cpu_to_le32(YRES_DEF); } primary = virtio_gpu_plane_init(vgdev, DRM_PLANE_TYPE_PRIMARY, index); if (IS_ERR(primary)) return PTR_ERR(primary); cursor = virtio_gpu_plane_init(vgdev, DRM_PLANE_TYPE_CURSOR, index); if (IS_ERR(cursor)) return PTR_ERR(cursor); drm_crtc_init_with_planes(dev, crtc, primary, cursor, &virtio_gpu_crtc_funcs, NULL); drm_crtc_helper_add(crtc, &virtio_gpu_crtc_helper_funcs); drm_connector_init(dev, connector, &virtio_gpu_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); drm_connector_helper_add(connector, &virtio_gpu_conn_helper_funcs); if (vgdev->has_edid) drm_connector_attach_edid_property(connector); drm_encoder_init(dev, encoder, &virtio_gpu_enc_funcs, DRM_MODE_ENCODER_VIRTUAL, NULL); drm_encoder_helper_add(encoder, &virtio_gpu_enc_helper_funcs); encoder->possible_crtcs = 1 << index; drm_connector_attach_encoder(connector, encoder); drm_connector_register(connector); return 0; }
int rcar_du_hdmi_connector_init(struct rcar_du_device *rcdu, struct rcar_du_encoder *renc) { struct drm_encoder *encoder = rcar_encoder_to_drm_encoder(renc); struct rcar_du_connector *rcon; struct drm_connector *connector; int ret; rcon = devm_kzalloc(rcdu->dev, sizeof(*rcon), GFP_KERNEL); if (rcon == NULL) return -ENOMEM; connector = &rcon->connector; connector->display_info.width_mm = 0; connector->display_info.height_mm = 0; connector->interlace_allowed = true; connector->polled = DRM_CONNECTOR_POLL_HPD; ret = drm_connector_init(rcdu->ddev, connector, &connector_funcs, DRM_MODE_CONNECTOR_HDMIA); if (ret < 0) return ret; drm_connector_helper_add(connector, &connector_helper_funcs); ret = drm_connector_register(connector); if (ret < 0) return ret; connector->dpms = 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; rcon->encoder = renc; return 0; }
struct drm_connector *meson_cvbs_connector_create(struct drm_device *dev, bool enabled, struct drm_display_mode *mode) { struct meson_connector *meson_connector; struct drm_connector *connector; struct drm_encoder *encoder; int ret; encoder = meson_encoder_create(dev); if (!encoder) return NULL; meson_connector = kzalloc(sizeof(*meson_connector), GFP_KERNEL); if (!meson_connector) return NULL; connector = &meson_connector->base; meson_connector->encoder = encoder; meson_connector->enabled = enabled; meson_connector->mode = mode; drm_connector_init(dev, connector, &meson_connector_funcs, DRM_MODE_CONNECTOR_Composite); drm_connector_helper_add(connector, &meson_connector_helper_funcs); connector->interlace_allowed = 1; connector->doublescan_allowed = 0; ret = drm_mode_connector_attach_encoder(connector, encoder); if (ret) goto fail; drm_connector_register(connector); return connector; fail: meson_connector_destroy(connector); return NULL; }
int rcar_du_vga_connector_init(struct rcar_du_device *rcdu, struct rcar_du_encoder *renc) { struct rcar_du_connector *rcon; struct drm_connector *connector; int ret; rcon = devm_kzalloc(rcdu->dev, sizeof(*rcon), GFP_KERNEL); if (rcon == NULL) return -ENOMEM; connector = &rcon->connector; connector->display_info.width_mm = 0; connector->display_info.height_mm = 0; ret = drm_connector_init(rcdu->ddev, connector, &connector_funcs, DRM_MODE_CONNECTOR_VGA); 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, &renc->encoder); if (ret < 0) return ret; connector->encoder = &renc->encoder; rcon->encoder = renc; return 0; }
static int vgdev_output_init(struct virtio_gpu_device *vgdev, int index) { struct drm_device *dev = vgdev->ddev; struct virtio_gpu_output *output = vgdev->outputs + index; struct drm_connector *connector = &output->conn; struct drm_encoder *encoder = &output->enc; struct drm_crtc *crtc = &output->crtc; struct drm_plane *plane; output->index = index; if (index == 0) { output->info.enabled = cpu_to_le32(true); output->info.r.width = cpu_to_le32(XRES_DEF); output->info.r.height = cpu_to_le32(YRES_DEF); } plane = virtio_gpu_plane_init(vgdev, index); if (IS_ERR(plane)) return PTR_ERR(plane); drm_crtc_init_with_planes(dev, crtc, plane, NULL, &virtio_gpu_crtc_funcs, NULL); drm_mode_crtc_set_gamma_size(crtc, 256); drm_crtc_helper_add(crtc, &virtio_gpu_crtc_helper_funcs); plane->crtc = crtc; drm_connector_init(dev, connector, &virtio_gpu_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); drm_connector_helper_add(connector, &virtio_gpu_conn_helper_funcs); drm_encoder_init(dev, encoder, &virtio_gpu_enc_funcs, DRM_MODE_ENCODER_VIRTUAL, NULL); drm_encoder_helper_add(encoder, &virtio_gpu_enc_helper_funcs); encoder->possible_crtcs = 1 << index; drm_mode_connector_attach_encoder(connector, encoder); drm_connector_register(connector); return 0; }
static struct drm_connector *panel_connector_create(struct drm_device *dev, struct panel_module *mod, struct drm_encoder *encoder) { struct panel_connector *panel_connector; struct drm_connector *connector; int ret; panel_connector = kzalloc(sizeof(*panel_connector), GFP_KERNEL); if (!panel_connector) { dev_err(dev->dev, "allocation failed\n"); return NULL; } panel_connector->encoder = encoder; panel_connector->mod = mod; connector = &panel_connector->base; drm_connector_init(dev, connector, &panel_connector_funcs, DRM_MODE_CONNECTOR_LVDS); drm_connector_helper_add(connector, &panel_connector_helper_funcs); connector->interlace_allowed = 0; connector->doublescan_allowed = 0; ret = drm_mode_connector_attach_encoder(connector, encoder); if (ret) goto fail; drm_connector_register(connector); return connector; fail: panel_connector_destroy(connector); return NULL; }
int ptn3460_init(struct drm_device *dev, struct drm_encoder *encoder, struct i2c_client *client, struct device_node *node) { int ret; struct drm_bridge *bridge; struct ptn3460_bridge *ptn_bridge; bridge = devm_kzalloc(dev->dev, sizeof(*bridge), GFP_KERNEL); if (!bridge) { DRM_ERROR("Failed to allocate drm bridge\n"); return -ENOMEM; } ptn_bridge = devm_kzalloc(dev->dev, sizeof(*ptn_bridge), GFP_KERNEL); if (!ptn_bridge) { DRM_ERROR("Failed to allocate ptn bridge\n"); return -ENOMEM; } ptn_bridge->client = client; ptn_bridge->encoder = encoder; ptn_bridge->bridge = bridge; ptn_bridge->gpio_pd_n = of_get_named_gpio(node, "powerdown-gpio", 0); if (gpio_is_valid(ptn_bridge->gpio_pd_n)) { ret = gpio_request_one(ptn_bridge->gpio_pd_n, GPIOF_OUT_INIT_HIGH, "PTN3460_PD_N"); if (ret) { DRM_ERROR("Request powerdown-gpio failed (%d)\n", ret); return ret; } } ptn_bridge->gpio_rst_n = of_get_named_gpio(node, "reset-gpio", 0); if (gpio_is_valid(ptn_bridge->gpio_rst_n)) { /* * Request the reset pin low to avoid the bridge being * initialized prematurely */ ret = gpio_request_one(ptn_bridge->gpio_rst_n, GPIOF_OUT_INIT_LOW, "PTN3460_RST_N"); if (ret) { DRM_ERROR("Request reset-gpio failed (%d)\n", ret); gpio_free(ptn_bridge->gpio_pd_n); return ret; } } ret = of_property_read_u32(node, "edid-emulation", &ptn_bridge->edid_emulation); if (ret) { DRM_ERROR("Can't read edid emulation value\n"); goto err; } ret = drm_bridge_init(dev, bridge, &ptn3460_bridge_funcs); if (ret) { DRM_ERROR("Failed to initialize bridge with drm\n"); goto err; } bridge->driver_private = ptn_bridge; encoder->bridge = bridge; ret = drm_connector_init(dev, &ptn_bridge->connector, &ptn3460_connector_funcs, DRM_MODE_CONNECTOR_LVDS); if (ret) { DRM_ERROR("Failed to initialize connector with drm\n"); goto err; } drm_connector_helper_add(&ptn_bridge->connector, &ptn3460_connector_helper_funcs); drm_connector_register(&ptn_bridge->connector); drm_mode_connector_attach_encoder(&ptn_bridge->connector, encoder); return 0; err: if (gpio_is_valid(ptn_bridge->gpio_pd_n)) gpio_free(ptn_bridge->gpio_pd_n); if (gpio_is_valid(ptn_bridge->gpio_rst_n)) gpio_free(ptn_bridge->gpio_rst_n); return ret; }
static int rcar_du_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct rcar_du_device *rcdu; struct drm_connector *connector; struct drm_device *ddev; struct resource *mem; int ret; if (np == NULL) { dev_err(&pdev->dev, "no device tree node\n"); return -ENODEV; } /* Allocate and initialize the DRM and R-Car device structures. */ rcdu = devm_kzalloc(&pdev->dev, sizeof(*rcdu), GFP_KERNEL); if (rcdu == NULL) return -ENOMEM; init_waitqueue_head(&rcdu->commit.wait); rcdu->dev = &pdev->dev; rcdu->info = of_match_device(rcar_du_of_table, rcdu->dev)->data; ddev = drm_dev_alloc(&rcar_du_driver, &pdev->dev); if (!ddev) return -ENOMEM; drm_dev_set_unique(ddev, dev_name(&pdev->dev)); rcdu->ddev = ddev; ddev->dev_private = rcdu; platform_set_drvdata(pdev, rcdu); /* I/O resources */ mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); rcdu->mmio = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(rcdu->mmio)) { ret = PTR_ERR(rcdu->mmio); goto error; } /* Initialize vertical blanking interrupts handling. Start with vblank * disabled for all CRTCs. */ ret = drm_vblank_init(ddev, (1 << rcdu->info->num_crtcs) - 1); if (ret < 0) { dev_err(&pdev->dev, "failed to initialize vblank\n"); goto error; } /* DRM/KMS objects */ ret = rcar_du_modeset_init(rcdu); if (ret < 0) { dev_err(&pdev->dev, "failed to initialize DRM/KMS (%d)\n", ret); goto error; } ddev->irq_enabled = 1; /* Register the DRM device with the core and the connectors with * sysfs. */ ret = drm_dev_register(ddev, 0); if (ret) goto error; mutex_lock(&ddev->mode_config.mutex); drm_for_each_connector(connector, ddev) { ret = drm_connector_register(connector); if (ret < 0) break; }
void cdv_hdmi_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev, int reg) { struct gma_encoder *gma_encoder; struct gma_connector *gma_connector; struct drm_connector *connector; struct drm_encoder *encoder; struct mid_intel_hdmi_priv *hdmi_priv; int ddc_bus; gma_encoder = kzalloc(sizeof(struct gma_encoder), GFP_KERNEL); if (!gma_encoder) return; gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL); if (!gma_connector) goto err_connector; hdmi_priv = kzalloc(sizeof(struct mid_intel_hdmi_priv), GFP_KERNEL); if (!hdmi_priv) goto err_priv; connector = &gma_connector->base; connector->polled = DRM_CONNECTOR_POLL_HPD; gma_connector->save = cdv_hdmi_save; gma_connector->restore = cdv_hdmi_restore; encoder = &gma_encoder->base; drm_connector_init(dev, connector, &cdv_hdmi_connector_funcs, DRM_MODE_CONNECTOR_DVID); drm_encoder_init(dev, encoder, &psb_intel_lvds_enc_funcs, DRM_MODE_ENCODER_TMDS, NULL); gma_connector_attach_encoder(gma_connector, gma_encoder); gma_encoder->type = INTEL_OUTPUT_HDMI; hdmi_priv->hdmi_reg = reg; hdmi_priv->has_hdmi_sink = false; gma_encoder->dev_priv = hdmi_priv; drm_encoder_helper_add(encoder, &cdv_hdmi_helper_funcs); drm_connector_helper_add(connector, &cdv_hdmi_connector_helper_funcs); connector->display_info.subpixel_order = SubPixelHorizontalRGB; connector->interlace_allowed = false; connector->doublescan_allowed = false; drm_object_attach_property(&connector->base, dev->mode_config.scaling_mode_property, DRM_MODE_SCALE_FULLSCREEN); switch (reg) { case SDVOB: ddc_bus = GPIOE; gma_encoder->ddi_select = DDI0_SELECT; break; case SDVOC: ddc_bus = GPIOD; gma_encoder->ddi_select = DDI1_SELECT; break; default: DRM_ERROR("unknown reg 0x%x for HDMI\n", reg); goto failed_ddc; break; } gma_encoder->i2c_bus = psb_intel_i2c_create(dev, ddc_bus, (reg == SDVOB) ? "HDMIB" : "HDMIC"); if (!gma_encoder->i2c_bus) { dev_err(dev->dev, "No ddc adapter available!\n"); goto failed_ddc; } hdmi_priv->hdmi_i2c_adapter = &(gma_encoder->i2c_bus->adapter); hdmi_priv->dev = dev; drm_connector_register(connector); return; failed_ddc: drm_encoder_cleanup(encoder); drm_connector_cleanup(connector); err_priv: kfree(gma_connector); err_connector: kfree(gma_encoder); }