static void meson_connector_destroy(struct drm_connector *connector) { struct meson_connector *meson_connector = to_meson_connector(connector); drm_mode_destroy(connector->dev, meson_connector->mode); drm_connector_cleanup(connector); kfree(meson_connector); }
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 panel_connector_destroy(struct drm_connector *connector) { struct panel_connector *panel_connector = to_panel_connector(connector); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(panel_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; }
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; }
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 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 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 cdv_intel_crt_destroy(struct drm_connector *connector) { struct psb_intel_output *intel_output = to_psb_intel_output(connector); psb_intel_i2c_destroy(intel_output->ddc_bus); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(connector); }
static void mdp4_lvds_connector_destroy(struct drm_connector *connector) { struct mdp4_lvds_connector *mdp4_lvds_connector = to_mdp4_lvds_connector(connector); drm_connector_cleanup(connector); kfree(mdp4_lvds_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 intel_dsi_destroy(struct drm_connector *connector) { struct intel_connector *intel_connector = to_intel_connector(connector); DRM_DEBUG_KMS("\n"); intel_panel_fini(&intel_connector->panel); drm_connector_cleanup(connector); kfree(connector); }
static void qxl_conn_destroy(struct drm_connector *connector) { struct qxl_output *qxl_output = drm_connector_to_qxl_output(connector); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(qxl_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 exynos_drm_connector_destroy(struct drm_connector *connector) { struct exynos_drm_connector *exynos_connector = to_exynos_connector(connector); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(exynos_connector); }
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 intel_hdmi_destroy(struct drm_connector *connector) { struct intel_output *intel_output = to_intel_output(connector); if (intel_output->i2c_bus) intel_i2c_destroy(intel_output->i2c_bus); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(intel_output); }
static void dsi_mgr_connector_destroy(struct drm_connector *connector) { struct dsi_connector *dsi_connector = to_dsi_connector(connector); DBG(""); drm_connector_cleanup(connector); kfree(dsi_connector); }
static void cdv_hdmi_destroy(struct drm_connector *connector) { struct gma_encoder *gma_encoder = gma_attached_encoder(connector); if (gma_encoder->i2c_bus) psb_intel_i2c_destroy(gma_encoder->i2c_bus); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(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_cleanup(connector); kfree(hdmi_connector); }
void vmw_display_unit_cleanup(struct vmw_display_unit *du) { if (du->cursor_surface) vmw_surface_unreference(&du->cursor_surface); if (du->cursor_dmabuf) vmw_dmabuf_unreference(&du->cursor_dmabuf); drm_crtc_cleanup(&du->crtc); drm_encoder_cleanup(&du->encoder); drm_connector_cleanup(&du->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 cdv_intel_crt_destroy(struct drm_connector *connector) { struct psb_intel_encoder *psb_intel_encoder = psb_intel_attached_encoder(connector); psb_intel_i2c_destroy(psb_intel_encoder->ddc_bus); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(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 CRTConnectorDestroy(struct drm_connector *psConnector) { PVRPSB_CONNECTOR *psPVRConnector = to_pvr_connector(psConnector); drm_mode_connector_update_edid_property(psConnector, NULL); drm_connector_cleanup(psConnector); PVRI2CAdapterDestroy(psPVRConnector->psAdapter); PVROSFreeKernelMem(psPVRConnector); }
static void intel_dp_mst_connector_destroy(struct drm_connector *connector) { struct intel_connector *intel_connector = to_intel_connector(connector); if (!IS_ERR_OR_NULL(intel_connector->edid)) kfree(intel_connector->edid); drm_connector_cleanup(connector); kfree(connector); }
static void exynos_drm_connector_destroy(struct drm_connector *connector) { struct exynos_drm_connector *exynos_connector = to_exynos_connector(connector); DRM_DEBUG_KMS("%s\n", __FILE__); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(exynos_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 vbox_connector_destroy(struct drm_connector *pConnector) { struct vbox_connector *pVBoxConnector = NULL; LogFunc(("vboxvideo: %d: connector=%p\n", __LINE__, pConnector)); pVBoxConnector = to_vbox_connector(pConnector); device_remove_file(pConnector->dev->dev, &pVBoxConnector->deviceAttribute); drm_sysfs_connector_remove(pConnector); drm_connector_cleanup(pConnector); kfree(pConnector); }