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);
}
