/* initialize encoder */ struct drm_encoder *mdp5_encoder_init(struct drm_device *dev, int intf, enum mdp5_intf intf_id) { struct drm_encoder *encoder = NULL; struct mdp5_encoder *mdp5_encoder; int ret; mdp5_encoder = kzalloc(sizeof(*mdp5_encoder), GFP_KERNEL); if (!mdp5_encoder) { ret = -ENOMEM; goto fail; } mdp5_encoder->intf = intf; mdp5_encoder->intf_id = intf_id; encoder = &mdp5_encoder->base; drm_encoder_init(dev, encoder, &mdp5_encoder_funcs, DRM_MODE_ENCODER_TMDS); drm_encoder_helper_add(encoder, &mdp5_encoder_helper_funcs); bs_init(mdp5_encoder); return encoder; fail: if (encoder) mdp5_encoder_destroy(encoder); return ERR_PTR(ret); }
struct drm_encoder *evdi_encoder_init(struct drm_device *dev) { struct drm_encoder *encoder; int ret = 0; encoder = kzalloc(sizeof(struct drm_encoder), GFP_KERNEL); if (!encoder) goto err; #if KERNEL_VERSION(4, 5, 0) <= LINUX_VERSION_CODE ret = drm_encoder_init(dev, encoder, &evdi_enc_funcs, DRM_MODE_ENCODER_TMDS, dev_name(dev->dev)); #else ret = drm_encoder_init(dev, encoder, &evdi_enc_funcs, DRM_MODE_ENCODER_TMDS); #endif if (ret) { EVDI_ERROR("Failed to initialize encoder: %d\n", ret); goto err_encoder; } drm_encoder_helper_add(encoder, &evdi_helper_funcs); encoder->possible_crtcs = 1; return encoder; err_encoder: kfree(encoder); err: return NULL; }
static struct drm_encoder * sti_tvout_create_dvo_encoder(struct drm_device *dev, struct sti_tvout *tvout) { struct sti_tvout_encoder *encoder; struct drm_encoder *drm_encoder; encoder = devm_kzalloc(tvout->dev, sizeof(*encoder), GFP_KERNEL); if (!encoder) return NULL; encoder->tvout = tvout; drm_encoder = (struct drm_encoder *)encoder; drm_encoder->possible_crtcs = ENCODER_CRTC_MASK; drm_encoder->possible_clones = 1 << 0; drm_encoder_init(dev, drm_encoder, &sti_tvout_encoder_funcs, DRM_MODE_ENCODER_LVDS, NULL); drm_encoder_helper_add(drm_encoder, &sti_dvo_encoder_helper_funcs); return drm_encoder; }
/* initialize encoder */ struct drm_encoder *mdp4_dsi_encoder_init(struct drm_device *dev) { struct drm_encoder *encoder = NULL; struct mdp4_dsi_encoder *mdp4_dsi_encoder; int ret; mdp4_dsi_encoder = kzalloc(sizeof(*mdp4_dsi_encoder), GFP_KERNEL); if (!mdp4_dsi_encoder) { ret = -ENOMEM; goto fail; } encoder = &mdp4_dsi_encoder->base; drm_encoder_init(dev, encoder, &mdp4_dsi_encoder_funcs, DRM_MODE_ENCODER_DSI, NULL); drm_encoder_helper_add(encoder, &mdp4_dsi_encoder_helper_funcs); return encoder; fail: if (encoder) mdp4_dsi_encoder_destroy(encoder); return ERR_PTR(ret); }
int nv50_dac_create(struct drm_device *dev, struct dcb_entry *entry) { struct nouveau_encoder *nv_encoder; struct drm_encoder *encoder; NV_DEBUG(dev, "\n"); NV_INFO(dev, "Detected a DAC output\n"); nv_encoder = kzalloc(sizeof(*nv_encoder), GFP_KERNEL); if (!nv_encoder) return -ENOMEM; encoder = to_drm_encoder(nv_encoder); nv_encoder->dcb = entry; nv_encoder->or = ffs(entry->or) - 1; nv_encoder->disconnect = nv50_dac_disconnect; drm_encoder_init(dev, encoder, &nv50_dac_encoder_funcs, DRM_MODE_ENCODER_DAC); drm_encoder_helper_add(encoder, &nv50_dac_helper_funcs); encoder->possible_crtcs = entry->heads; encoder->possible_clones = 0; return 0; }
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; }
static struct drm_encoder *panel_encoder_create(struct drm_device *dev, struct panel_module *mod) { struct panel_encoder *panel_encoder; struct drm_encoder *encoder; int ret; panel_encoder = kzalloc(sizeof(*panel_encoder), GFP_KERNEL); if (!panel_encoder) { dev_err(dev->dev, "allocation failed\n"); return NULL; } panel_encoder->mod = mod; encoder = &panel_encoder->base; encoder->possible_crtcs = 1; ret = drm_encoder_init(dev, encoder, &panel_encoder_funcs, DRM_MODE_ENCODER_LVDS); if (ret < 0) goto fail; drm_encoder_helper_add(encoder, &panel_encoder_helper_funcs); return encoder; fail: panel_encoder_destroy(encoder); return NULL; }
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 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; }
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; }
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; }
int hibmc_vdac_init(struct hibmc_drm_private *priv) { struct drm_device *dev = priv->dev; struct drm_encoder *encoder; struct drm_connector *connector; int ret; connector = hibmc_connector_init(priv); if (IS_ERR(connector)) { DRM_ERROR("failed to create connector: %ld\n", PTR_ERR(connector)); return PTR_ERR(connector); } encoder = devm_kzalloc(dev->dev, sizeof(*encoder), GFP_KERNEL); if (!encoder) { DRM_ERROR("failed to alloc memory when init encoder\n"); return -ENOMEM; } encoder->possible_crtcs = 0x1; ret = drm_encoder_init(dev, encoder, &hibmc_encoder_funcs, DRM_MODE_ENCODER_DAC, NULL); if (ret) { DRM_ERROR("failed to init encoder: %d\n", ret); return ret; } drm_encoder_helper_add(encoder, &hibmc_encoder_helper_funcs); drm_connector_attach_encoder(connector, 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; 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_pd_register(struct imx_parallel_display *imxpd) { int ret; drm_mode_connector_attach_encoder(&imxpd->connector, &imxpd->encoder); imxpd->connector.funcs = &imx_pd_connector_funcs; imxpd->encoder.funcs = &imx_pd_encoder_funcs; imxpd->encoder.encoder_type = DRM_MODE_ENCODER_NONE; imxpd->connector.connector_type = DRM_MODE_CONNECTOR_VGA; drm_encoder_helper_add(&imxpd->encoder, &imx_pd_encoder_helper_funcs); ret = imx_drm_add_encoder(&imxpd->encoder, &imxpd->imx_drm_encoder, THIS_MODULE); if (ret) { dev_err(imxpd->dev, "adding encoder failed with %d\n", ret); return ret; } drm_connector_helper_add(&imxpd->connector, &imx_pd_connector_helper_funcs); ret = imx_drm_add_connector(&imxpd->connector, &imxpd->imx_drm_connector, THIS_MODULE); if (ret) { imx_drm_remove_encoder(imxpd->imx_drm_encoder); dev_err(imxpd->dev, "adding connector failed with %d\n", ret); return ret; } imxpd->connector.encoder = &imxpd->encoder; 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 bochs_encoder_init(struct drm_device *dev) { struct bochs_device *bochs = dev->dev_private; struct drm_encoder *encoder = &bochs->encoder; encoder->possible_crtcs = 0x1; drm_encoder_init(dev, encoder, &bochs_encoder_encoder_funcs, DRM_MODE_ENCODER_DAC); drm_encoder_helper_add(encoder, &bochs_encoder_helper_funcs); }
static int dw_hdmi_imx_bind(struct device *dev, struct device *master, void *data) { struct platform_device *pdev = to_platform_device(dev); const struct dw_hdmi_plat_data *plat_data; const struct of_device_id *match; struct drm_device *drm = data; struct drm_encoder *encoder; struct imx_hdmi *hdmi; struct resource *iores; int irq; int ret; if (!pdev->dev.of_node) return -ENODEV; hdmi = devm_kzalloc(&pdev->dev, sizeof(*hdmi), GFP_KERNEL); if (!hdmi) return -ENOMEM; match = of_match_node(dw_hdmi_imx_dt_ids, pdev->dev.of_node); plat_data = match->data; hdmi->dev = &pdev->dev; encoder = &hdmi->encoder; irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; iores = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!iores) return -ENXIO; platform_set_drvdata(pdev, hdmi); encoder->possible_crtcs = drm_of_find_possible_crtcs(drm, dev->of_node); /* * If we failed to find the CRTC(s) which this encoder is * supposed to be connected to, it's because the CRTC has * not been registered yet. Defer probing, and hope that * the required CRTC is added later. */ if (encoder->possible_crtcs == 0) return -EPROBE_DEFER; ret = dw_hdmi_imx_parse_dt(hdmi); if (ret < 0) return ret; drm_encoder_helper_add(encoder, &dw_hdmi_imx_encoder_helper_funcs); drm_encoder_init(drm, encoder, &dw_hdmi_imx_encoder_funcs, DRM_MODE_ENCODER_TMDS, NULL); return dw_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data); }
/* initialize encoder */ struct drm_encoder * omap_encoder_init(struct drm_device *dev, struct omap_overlay_manager *mgr) { struct drm_encoder *encoder = NULL; struct omap_encoder *omap_encoder; struct omap_overlay_manager_info info; int ret; DBG("%s", mgr->name); omap_encoder = kzalloc(sizeof(*omap_encoder), GFP_KERNEL); if (!omap_encoder) { dev_err(dev->dev, "could not allocate encoder\n"); goto fail; } omap_encoder->mgr = mgr; encoder = &omap_encoder->base; mgr->get_manager_info(mgr, &info); /* TODO: fix hard-coded setup.. */ info.default_color = 0x00000000; info.trans_key = 0x00000000; info.trans_key_type = OMAP_DSS_COLOR_KEY_GFX_DST; info.trans_enabled = false; info.alpha_enabled = false; ret = mgr->set_manager_info(mgr, &info); if (ret) { dev_err(dev->dev, "could not set manager info\n"); goto fail; } ret = mgr->apply(mgr); if (ret) { dev_err(dev->dev, "could not apply\n"); goto fail; } drm_encoder_init(dev, encoder, &omap_encoder_funcs, DRM_MODE_ENCODER_TMDS); drm_encoder_helper_add(encoder, &omap_encoder_helper_funcs); return encoder; fail: if (encoder) { drm_encoder_cleanup(encoder); kfree(omap_encoder); } return NULL; }
struct drm_encoder *udl_encoder_init(struct drm_device *dev) { struct drm_encoder *encoder; encoder = kzalloc(sizeof(struct drm_encoder), GFP_KERNEL); if (!encoder) return NULL; drm_encoder_init(dev, encoder, &udl_enc_funcs, DRM_MODE_ENCODER_TMDS); drm_encoder_helper_add(encoder, &udl_helper_funcs); encoder->possible_crtcs = 1; return encoder; }
int nv04_tv_create(struct drm_connector *connector, struct dcb_output *entry) { struct nouveau_encoder *nv_encoder; struct drm_encoder *encoder; struct drm_device *dev = connector->dev; struct nouveau_drm *drm = nouveau_drm(dev); struct nvkm_i2c *i2c = nvxx_i2c(&drm->device); struct nvkm_i2c_port *port = i2c->find(i2c, entry->i2c_index); int type, ret; /* Ensure that we can talk to this encoder */ type = nv04_tv_identify(dev, entry->i2c_index); if (type < 0) return type; /* Allocate the necessary memory */ nv_encoder = kzalloc(sizeof(*nv_encoder), GFP_KERNEL); if (!nv_encoder) return -ENOMEM; /* Initialize the common members */ encoder = to_drm_encoder(nv_encoder); drm_encoder_init(dev, encoder, &nv04_tv_funcs, DRM_MODE_ENCODER_TVDAC); drm_encoder_helper_add(encoder, &nv04_tv_helper_funcs); encoder->possible_crtcs = entry->heads; encoder->possible_clones = 0; nv_encoder->dcb = entry; nv_encoder->or = ffs(entry->or) - 1; /* Run the slave-specific initialization */ ret = drm_i2c_encoder_init(dev, to_encoder_slave(encoder), &port->adapter, &nv04_tv_encoder_info[type].dev); if (ret < 0) goto fail_cleanup; /* Attach it to the specified connector. */ get_slave_funcs(encoder)->create_resources(encoder, connector); drm_mode_connector_attach_encoder(connector, encoder); return 0; fail_cleanup: drm_encoder_cleanup(encoder); kfree(nv_encoder); return ret; }
int nv50_sor_create(struct drm_device *dev, struct dcb_entry *entry) { struct nouveau_encoder *nv_encoder = NULL; struct drm_encoder *encoder; bool dum; int type; NV_DEBUG_KMS(dev, "\n"); switch (entry->type) { case OUTPUT_TMDS: NV_INFO(dev, "Detected a TMDS output\n"); type = DRM_MODE_ENCODER_TMDS; break; case OUTPUT_LVDS: NV_INFO(dev, "Detected a LVDS output\n"); type = DRM_MODE_ENCODER_LVDS; if (nouveau_bios_parse_lvds_table(dev, 0, &dum, &dum)) { NV_ERROR(dev, "Failed parsing LVDS table\n"); return -EINVAL; } break; case OUTPUT_DP: NV_INFO(dev, "Detected a DP output\n"); type = DRM_MODE_ENCODER_TMDS; break; default: return -EINVAL; } nv_encoder = kzalloc(sizeof(*nv_encoder), GFP_KERNEL); if (!nv_encoder) return -ENOMEM; encoder = to_drm_encoder(nv_encoder); nv_encoder->dcb = entry; nv_encoder->or = ffs(entry->or) - 1; nv_encoder->disconnect = nv50_sor_disconnect; drm_encoder_init(dev, encoder, &nv50_sor_encoder_funcs, type); drm_encoder_helper_add(encoder, &nv50_sor_helper_funcs); encoder->possible_crtcs = entry->heads; encoder->possible_clones = 0; return 0; }
/* initialize encoder */ struct drm_encoder *mdp4_dtv_encoder_init(struct drm_device *dev) { struct drm_encoder *encoder = NULL; struct mdp4_dtv_encoder *mdp4_dtv_encoder; int ret; mdp4_dtv_encoder = kzalloc(sizeof(*mdp4_dtv_encoder), GFP_KERNEL); if (!mdp4_dtv_encoder) { ret = -ENOMEM; goto fail; } encoder = &mdp4_dtv_encoder->base; drm_encoder_init(dev, encoder, &mdp4_dtv_encoder_funcs, DRM_MODE_ENCODER_TMDS, NULL); drm_encoder_helper_add(encoder, &mdp4_dtv_encoder_helper_funcs); mdp4_dtv_encoder->src_clk = devm_clk_get(dev->dev, "src_clk"); if (IS_ERR(mdp4_dtv_encoder->src_clk)) { dev_err(dev->dev, "failed to get src_clk\n"); ret = PTR_ERR(mdp4_dtv_encoder->src_clk); goto fail; } mdp4_dtv_encoder->hdmi_clk = devm_clk_get(dev->dev, "hdmi_clk"); if (IS_ERR(mdp4_dtv_encoder->hdmi_clk)) { dev_err(dev->dev, "failed to get hdmi_clk\n"); ret = PTR_ERR(mdp4_dtv_encoder->hdmi_clk); goto fail; } mdp4_dtv_encoder->mdp_clk = devm_clk_get(dev->dev, "mdp_clk"); if (IS_ERR(mdp4_dtv_encoder->mdp_clk)) { dev_err(dev->dev, "failed to get mdp_clk\n"); ret = PTR_ERR(mdp4_dtv_encoder->mdp_clk); goto fail; } bs_init(mdp4_dtv_encoder); return encoder; fail: if (encoder) mdp4_dtv_encoder_destroy(encoder); return ERR_PTR(ret); }
struct drm_encoder *evdi_encoder_init(struct drm_device *dev) { struct drm_encoder *encoder; int status = 0; encoder = kzalloc(sizeof(struct drm_encoder), GFP_KERNEL); if (!encoder) { return NULL; } status = drm_encoder_init(dev, encoder, &evdi_enc_funcs, DRM_MODE_ENCODER_TMDS); EVDI_DEBUG("drm_encoder_init: %d\n", status); drm_encoder_helper_add(encoder, &evdi_helper_funcs); encoder->possible_crtcs = 1; return encoder; }
int fsl_dcu_drm_encoder_create(struct fsl_dcu_drm_device *fsl_dev, struct drm_crtc *crtc) { struct drm_encoder *encoder = &fsl_dev->encoder; int ret; encoder->possible_crtcs = 1; ret = drm_encoder_init(fsl_dev->drm, encoder, &encoder_funcs, DRM_MODE_ENCODER_LVDS, NULL); if (ret < 0) return ret; drm_encoder_helper_add(encoder, &encoder_helper_funcs); return 0; }
int rcar_du_hdmienc_init(struct rcar_du_device *rcdu, struct rcar_du_encoder *renc, struct device_node *np) { struct drm_encoder *encoder = rcar_encoder_to_drm_encoder(renc); struct drm_i2c_encoder_driver *driver; struct i2c_client *i2c_slave; struct rcar_du_hdmienc *hdmienc; int ret; hdmienc = devm_kzalloc(rcdu->dev, sizeof(*hdmienc), GFP_KERNEL); if (hdmienc == NULL) return -ENOMEM; /* Locate the slave I2C device and driver. */ i2c_slave = of_find_i2c_device_by_node(np); if (!i2c_slave || !i2c_get_clientdata(i2c_slave)) return -EPROBE_DEFER; hdmienc->dev = &i2c_slave->dev; if (hdmienc->dev->driver == NULL) { ret = -EPROBE_DEFER; goto error; } /* Initialize the slave encoder. */ driver = to_drm_i2c_encoder_driver(to_i2c_driver(hdmienc->dev->driver)); ret = driver->encoder_init(i2c_slave, rcdu->ddev, &renc->slave); if (ret < 0) goto error; ret = drm_encoder_init(rcdu->ddev, encoder, &encoder_funcs, DRM_MODE_ENCODER_TMDS); if (ret < 0) goto error; drm_encoder_helper_add(encoder, &encoder_helper_funcs); renc->hdmi = hdmienc; hdmienc->renc = renc; return 0; error: put_device(hdmienc->dev); return ret; }
static int exynos_dp_bind(struct device *dev, struct device *master, void *data) { struct exynos_dp_device *dp = dev_get_drvdata(dev); struct drm_encoder *encoder = &dp->encoder; struct drm_device *drm_dev = data; int pipe, ret; /* * Just like the probe function said, we don't need the * device drvrate anymore, we should leave the charge to * analogix dp driver, set the device drvdata to NULL. */ dev_set_drvdata(dev, NULL); dp->dev = dev; dp->drm_dev = drm_dev; dp->plat_data.dev_type = EXYNOS_DP; dp->plat_data.power_on = exynos_dp_poweron; dp->plat_data.power_off = exynos_dp_poweroff; dp->plat_data.attach = exynos_dp_bridge_attach; dp->plat_data.get_modes = exynos_dp_get_modes; if (!dp->plat_data.panel && !dp->ptn_bridge) { ret = exynos_dp_dt_parse_panel(dp); if (ret) return ret; } pipe = exynos_drm_crtc_get_pipe_from_type(drm_dev, EXYNOS_DISPLAY_TYPE_LCD); if (pipe < 0) return pipe; encoder->possible_crtcs = 1 << pipe; DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs); drm_encoder_init(drm_dev, encoder, &exynos_dp_encoder_funcs, DRM_MODE_ENCODER_TMDS, NULL); drm_encoder_helper_add(encoder, &exynos_dp_encoder_helper_funcs); dp->plat_data.encoder = encoder; return analogix_dp_bind(dev, dp->drm_dev, &dp->plat_data); }
static PVRPSB_ENCODER *CRTEncoderCreate(PVRPSB_DEVINFO *psDevInfo) { PVRPSB_ENCODER *psPVREncoder; psPVREncoder = (PVRPSB_ENCODER *)kzalloc(sizeof(PVRPSB_ENCODER), GFP_KERNEL); if (psPVREncoder) { drm_encoder_init(psDevInfo->psDrmDev, &psPVREncoder->sEncoder, &sCRTEncoderFuncs, DRM_MODE_ENCODER_DAC); drm_encoder_helper_add(&psPVREncoder->sEncoder, &sCRTEncoderHelperFuncs); /* This is a bit field that's used to determine by which CRTCs the encoder can be driven. We have only one CRTC so always set to 0x1 */ psPVREncoder->sEncoder.possible_crtcs = 0x1; } return psPVREncoder; }
struct drm_encoder *vbox_encoder_init(struct drm_device *dev, unsigned i) { struct vbox_encoder *vbox_encoder; LogFunc(("vboxvideo: %d: dev=%d\n", __LINE__)); vbox_encoder = kzalloc(sizeof(struct vbox_encoder), GFP_KERNEL); if (!vbox_encoder) return NULL; drm_encoder_init(dev, &vbox_encoder->base, &vbox_enc_funcs, DRM_MODE_ENCODER_DAC); drm_encoder_helper_add(&vbox_encoder->base, &vbox_enc_helper_funcs); vbox_encoder->base.possible_crtcs = 1 << i; LogFunc(("vboxvideo: %d: vbox_encoder=%p\n", __LINE__, vbox_encoder)); return &vbox_encoder->base; }
int hibmc_encoder_init(struct hibmc_drm_device *hidev) { struct drm_device *dev = hidev->dev; struct drm_encoder *encoder = &hidev->encoder; int ret; encoder->possible_crtcs = 0x1; ret = drm_encoder_init(dev, encoder, &hibmc_encoder_encoder_funcs, DRM_MODE_ENCODER_DAC); if (ret) { DRM_ERROR("failed to init encoder\n"); return ret; } drm_encoder_helper_add(encoder, &hibmc_encoder_helper_funcs); return 0; }