static void panel_connector_destroy(struct drm_connector *connector) { struct panel_connector *panel_connector = to_panel_connector(connector); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(panel_connector); }
static void fsl_dcu_drm_connector_destroy(struct drm_connector *connector) { struct fsl_dcu_drm_connector *fsl_con = to_fsl_dcu_connector(connector); drm_connector_unregister(connector); drm_panel_detach(fsl_con->panel); drm_connector_cleanup(connector); }
static void shmob_drm_connector_destroy(struct drm_connector *connector) { struct shmob_drm_connector *scon = to_shmob_connector(connector); shmob_drm_backlight_exit(scon); drm_connector_unregister(connector); drm_connector_cleanup(connector); }
static void virtio_gpu_conn_destroy(struct drm_connector *connector) { struct virtio_gpu_output *virtio_gpu_output = drm_connector_to_virtio_gpu_output(connector); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(virtio_gpu_output); }
static void qxl_conn_destroy(struct drm_connector *connector) { struct qxl_output *qxl_output = drm_connector_to_qxl_output(connector); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(qxl_output); }
static void cdv_hdmi_destroy(struct drm_connector *connector) { struct gma_encoder *gma_encoder = gma_attached_encoder(connector); psb_intel_i2c_destroy(gma_encoder->i2c_bus); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(connector); }
static void edp_connector_destroy(struct drm_connector *connector) { struct edp_connector *edp_connector = to_edp_connector(connector); DBG(""); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(edp_connector); }
static void mxsfb_panel_connector_destroy(struct drm_connector *connector) { struct mxsfb_drm_private *mxsfb = drm_connector_to_mxsfb_drm_private(connector); if (mxsfb->panel) drm_panel_detach(mxsfb->panel); drm_connector_unregister(connector); drm_connector_cleanup(connector); }
static void hdmi_connector_destroy(struct drm_connector *connector) { struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector); hdp_disable(hdmi_connector); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(hdmi_connector); }
static void pl111_connector_destroy(struct drm_connector *connector) { struct pl111_drm_connector *pl111_connector = to_pl111_connector(connector); if (pl111_connector->panel) drm_panel_detach(pl111_connector->panel); drm_connector_unregister(connector); drm_connector_cleanup(connector); }
static void omap_connector_destroy(struct drm_connector *connector) { struct omap_connector *omap_connector = to_omap_connector(connector); struct omap_dss_device *dssdev = omap_connector->dssdev; DBG("%s", omap_connector->dssdev->name); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(omap_connector); omap_dss_put_device(dssdev); }
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; }
static void mdp4_lvds_connector_destroy(struct drm_connector *connector) { struct mdp4_lvds_connector *mdp4_lvds_connector = to_mdp4_lvds_connector(connector); struct drm_panel *panel = mdp4_lvds_connector->panel; if (panel) drm_panel_detach(panel); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(mdp4_lvds_connector); }
static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr, struct drm_connector *connector) { struct drm_i915_private *dev_priv = to_i915(connector->dev); DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id, connector->name); drm_connector_unregister(connector); if (dev_priv->fbdev) drm_fb_helper_remove_one_connector(&dev_priv->fbdev->helper, connector); drm_connector_put(connector); }
static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr, struct drm_connector *connector) { struct intel_connector *intel_connector = to_intel_connector(connector); struct drm_device *dev = connector->dev; drm_connector_unregister(connector); /* need to nuke the connector */ drm_modeset_lock_all(dev); intel_connector_remove_from_fbdev(intel_connector); intel_connector->mst_port = NULL; drm_modeset_unlock_all(dev); drm_connector_unreference(&intel_connector->base); DRM_DEBUG_KMS("\n"); }
static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr, struct drm_connector *connector) { struct intel_connector *intel_connector = to_intel_connector(connector); struct drm_i915_private *dev_priv = to_i915(connector->dev); DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id, connector->name); drm_connector_unregister(connector); if (dev_priv->fbdev) drm_fb_helper_remove_one_connector(&dev_priv->fbdev->helper, connector); /* prevent race with the check in ->detect */ drm_modeset_lock(&connector->dev->mode_config.connection_mutex, NULL); intel_connector->mst_port = NULL; drm_modeset_unlock(&connector->dev->mode_config.connection_mutex); drm_connector_unreference(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; }
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 void sde_connector_destroy(struct drm_connector *connector) { struct sde_connector *c_conn; if (!connector) { SDE_ERROR("invalid connector\n"); return; } c_conn = to_sde_connector(connector); if (c_conn->ops.pre_deinit) c_conn->ops.pre_deinit(connector, c_conn->display); if (c_conn->blob_caps) drm_property_unreference_blob(c_conn->blob_caps); msm_property_destroy(&c_conn->property_info); drm_connector_unregister(connector); sde_fence_deinit(&c_conn->retire_fence); drm_connector_cleanup(connector); kfree(c_conn); }
static void rcar_du_hdmi_connector_destroy(struct drm_connector *connector) { drm_connector_unregister(connector); drm_connector_cleanup(connector); }
static void exynos_dp_connector_destroy(struct drm_connector *connector) { drm_connector_unregister(connector); drm_connector_cleanup(connector); }
static void dce_virtual_destroy(struct drm_connector *connector) { drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(connector); }
struct drm_connector *sde_connector_init(struct drm_device *dev, struct drm_encoder *encoder, struct drm_panel *panel, void *display, const struct sde_connector_ops *ops, int connector_poll, int connector_type) { struct msm_drm_private *priv; struct sde_kms *sde_kms; struct sde_kms_info *info; struct sde_connector *c_conn = NULL; int rc; if (!dev || !dev->dev_private || !encoder) { SDE_ERROR("invalid argument(s), dev %pK, enc %pK\n", dev, encoder); return ERR_PTR(-EINVAL); } priv = dev->dev_private; if (!priv->kms) { SDE_ERROR("invalid kms reference\n"); return ERR_PTR(-EINVAL); } c_conn = kzalloc(sizeof(*c_conn), GFP_KERNEL); if (!c_conn) { SDE_ERROR("failed to alloc sde connector\n"); return ERR_PTR(-ENOMEM); } rc = drm_connector_init(dev, &c_conn->base, &sde_connector_ops, connector_type); if (rc) goto error_free_conn; c_conn->connector_type = connector_type; c_conn->encoder = encoder; c_conn->panel = panel; c_conn->display = display; /* cache mmu_id's for later */ sde_kms = to_sde_kms(priv->kms); if (sde_kms->vbif[VBIF_NRT]) { c_conn->mmu_id[SDE_IOMMU_DOMAIN_UNSECURE] = sde_kms->mmu_id[MSM_SMMU_DOMAIN_NRT_UNSECURE]; c_conn->mmu_id[SDE_IOMMU_DOMAIN_SECURE] = sde_kms->mmu_id[MSM_SMMU_DOMAIN_NRT_SECURE]; } else { c_conn->mmu_id[SDE_IOMMU_DOMAIN_UNSECURE] = sde_kms->mmu_id[MSM_SMMU_DOMAIN_UNSECURE]; c_conn->mmu_id[SDE_IOMMU_DOMAIN_SECURE] = sde_kms->mmu_id[MSM_SMMU_DOMAIN_SECURE]; } if (ops) c_conn->ops = *ops; c_conn->base.helper_private = &sde_connector_helper_ops; c_conn->base.polled = connector_poll; c_conn->base.interlace_allowed = 0; c_conn->base.doublescan_allowed = 0; snprintf(c_conn->name, SDE_CONNECTOR_NAME_SIZE, "conn%u", c_conn->base.base.id); /* * Initialize retire fence support. Set fence offset to 0 for virtual * connectors so that the fence signals at the end of the current commit * and 1 for others so that the fence signals after one additional * commit. */ rc = sde_fence_init(dev, &c_conn->retire_fence, c_conn->name, connector_type == DRM_MODE_CONNECTOR_VIRTUAL ? 0 : 1); if (rc) { SDE_ERROR("failed to init fence, %d\n", rc); goto error_cleanup_conn; } rc = drm_connector_register(&c_conn->base); if (rc) { SDE_ERROR("failed to register drm connector, %d\n", rc); goto error_cleanup_fence; } rc = drm_mode_connector_attach_encoder(&c_conn->base, encoder); if (rc) { SDE_ERROR("failed to attach encoder to connector, %d\n", rc); goto error_unregister_conn; } /* create properties */ msm_property_init(&c_conn->property_info, &c_conn->base.base, dev, priv->conn_property, c_conn->property_data, CONNECTOR_PROP_COUNT, CONNECTOR_PROP_BLOBCOUNT, sizeof(struct sde_connector_state)); if (c_conn->ops.post_init) { info = kmalloc(sizeof(*info), GFP_KERNEL); if (!info) { SDE_ERROR("failed to allocate info buffer\n"); rc = -ENOMEM; goto error_unregister_conn; } sde_kms_info_reset(info); rc = c_conn->ops.post_init(&c_conn->base, info, display); if (rc) { SDE_ERROR("post-init failed, %d\n", rc); kfree(info); goto error_unregister_conn; } msm_property_install_blob(&c_conn->property_info, "capabilities", DRM_MODE_PROP_IMMUTABLE, CONNECTOR_PROP_SDE_INFO); msm_property_set_blob(&c_conn->property_info, &c_conn->blob_caps, SDE_KMS_INFO_DATA(info), SDE_KMS_INFO_DATALEN(info), CONNECTOR_PROP_SDE_INFO); kfree(info); } msm_property_install_range(&c_conn->property_info, "RETIRE_FENCE", 0x0, 0, INR_OPEN_MAX, 0, CONNECTOR_PROP_RETIRE_FENCE); /* enum/bitmask properties */ msm_property_install_enum(&c_conn->property_info, "topology_name", DRM_MODE_PROP_IMMUTABLE, 0, e_topology_name, ARRAY_SIZE(e_topology_name), CONNECTOR_PROP_TOPOLOGY_NAME, 0); msm_property_install_enum(&c_conn->property_info, "topology_control", 0, 1, e_topology_control, ARRAY_SIZE(e_topology_control), CONNECTOR_PROP_TOPOLOGY_CONTROL, 0); rc = msm_property_install_get_status(&c_conn->property_info); if (rc) { SDE_ERROR("failed to create one or more properties\n"); goto error_destroy_property; } SDE_DEBUG("connector %d attach encoder %d\n", c_conn->base.base.id, encoder->base.id); priv->connectors[priv->num_connectors++] = &c_conn->base; return &c_conn->base; error_destroy_property: if (c_conn->blob_caps) drm_property_unreference_blob(c_conn->blob_caps); msm_property_destroy(&c_conn->property_info); error_unregister_conn: drm_connector_unregister(&c_conn->base); error_cleanup_fence: sde_fence_deinit(&c_conn->retire_fence); error_cleanup_conn: drm_connector_cleanup(&c_conn->base); error_free_conn: kfree(c_conn); return ERR_PTR(rc); }
static void dw_mipi_dsi_drm_connector_destroy(struct drm_connector *connector) { drm_connector_unregister(connector); drm_connector_cleanup(connector); }
static void tegra_connector_destroy(struct drm_connector *connector) { drm_connector_unregister(connector); drm_connector_cleanup(connector); drm_connector_clear(connector); }
static void analogix_dp_connector_destroy(struct drm_connector *connector) { drm_connector_unregister(connector); drm_connector_cleanup(connector); }
int vkms_output_init(struct vkms_device *vkmsdev) { struct vkms_output *output = &vkmsdev->output; struct drm_device *dev = &vkmsdev->drm; struct drm_connector *connector = &output->connector; struct drm_encoder *encoder = &output->encoder; struct drm_crtc *crtc = &output->crtc; struct drm_plane *primary, *cursor = NULL; int ret; primary = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_PRIMARY); if (IS_ERR(primary)) return PTR_ERR(primary); if (enable_cursor) { cursor = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_CURSOR); if (IS_ERR(cursor)) { ret = PTR_ERR(cursor); goto err_cursor; } } ret = vkms_crtc_init(dev, crtc, primary, cursor); if (ret) goto err_crtc; ret = drm_connector_init(dev, connector, &vkms_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL); if (ret) { DRM_ERROR("Failed to init connector\n"); goto err_connector; } drm_connector_helper_add(connector, &vkms_conn_helper_funcs); ret = drm_connector_register(connector); if (ret) { DRM_ERROR("Failed to register connector\n"); goto err_connector_register; } ret = drm_encoder_init(dev, encoder, &vkms_encoder_funcs, DRM_MODE_ENCODER_VIRTUAL, NULL); if (ret) { DRM_ERROR("Failed to init encoder\n"); goto err_encoder; } encoder->possible_crtcs = 1; ret = drm_connector_attach_encoder(connector, encoder); if (ret) { DRM_ERROR("Failed to attach connector to encoder\n"); goto err_attach; } drm_mode_config_reset(dev); return 0; err_attach: drm_encoder_cleanup(encoder); err_encoder: drm_connector_unregister(connector); err_connector_register: drm_connector_cleanup(connector); err_connector: drm_crtc_cleanup(crtc); err_crtc: if (enable_cursor) drm_plane_cleanup(cursor); err_cursor: drm_plane_cleanup(primary); return ret; }
static void arcpgu_drm_connector_destroy(struct drm_connector *connector) { drm_connector_unregister(connector); drm_connector_cleanup(connector); }
/* destroy connector */ void xilinx_drm_connector_destroy(struct drm_connector *base_connector) { drm_connector_unregister(base_connector); drm_connector_cleanup(base_connector); }
/* create connector */ struct drm_connector * xilinx_drm_connector_create(struct drm_device *drm, struct drm_encoder *base_encoder, int id) { struct xilinx_drm_connector *connector; const char *string; int type = DRM_MODE_CONNECTOR_Unknown; int i, ret; connector = devm_kzalloc(drm->dev, sizeof(*connector), GFP_KERNEL); if (!connector) return ERR_PTR(-ENOMEM); connector->base.polled = DRM_CONNECTOR_POLL_HPD | DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT; ret = of_property_read_string_index(drm->dev->of_node, "xlnx,connector-type", id, &string); if (ret < 0) { dev_err(drm->dev, "No connector type in DT\n"); return ERR_PTR(ret); } for (i = 0; i < ARRAY_SIZE(connector_types); i++) if (strcmp(connector_types[i].name, string) == 0) { type = connector_types[i].type; break; } if (type == DRM_MODE_CONNECTOR_Unknown) { dev_err(drm->dev, "Unknown connector type in DT\n"); return ERR_PTR(-EINVAL); } ret = drm_connector_init(drm, &connector->base, &xilinx_drm_connector_funcs, type); if (ret) { DRM_ERROR("failed to initialize connector\n"); return ERR_PTR(ret); } drm_connector_helper_add(&connector->base, &xilinx_drm_connector_helper_funcs); /* add entry for connector */ ret = drm_connector_register(&connector->base); if (ret) { DRM_ERROR("failed to register a connector\n"); goto err_register; } /* connect connector and encoder */ ret = drm_connector_attach_encoder(&connector->base, base_encoder); if (ret) { DRM_ERROR("failed to attach connector to encoder\n"); goto err_attach; } connector->encoder = base_encoder; connector->base.dpms = DRM_MODE_DPMS_OFF; return &connector->base; err_attach: drm_connector_unregister(&connector->base); err_register: drm_connector_cleanup(&connector->base); return ERR_PTR(ret); }