/** * intel_connector_update_modes - update connector from edid * @connector: DRM connector device to use * @edid: previously read EDID information */ int intel_connector_update_modes(struct drm_connector *connector, struct edid *edid) { int ret; drm_mode_connector_update_edid_property(connector, edid); ret = drm_add_edid_modes(connector, edid); drm_edid_to_eld(connector, edid); return ret; }
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); }
/** * intel_connector_update_modes - update connector from edid * @connector: DRM connector device to use * @edid: previously read EDID information */ int intel_connector_update_modes(struct drm_connector *connector, struct edid *edid) { int ret; drm_mode_connector_update_edid_property(connector, edid); ret = drm_add_edid_modes(connector, edid); drm_edid_to_eld(connector, edid); connector->display_info.raw_edid = NULL; kfree(edid); return ret; }
static int udl_get_modes(struct drm_connector *connector) { struct udl_device *udl = connector->dev->dev_private; struct edid *edid; int ret; edid = (struct edid *)udl_get_edid(udl); drm_mode_connector_update_edid_property(connector, edid); ret = drm_add_edid_modes(connector, edid); kfree(edid); return ret; }
/* * Return the list of HDMI DDC modes if available. */ static int cdv_hdmi_get_modes(struct drm_connector *connector) { struct gma_encoder *gma_encoder = gma_attached_encoder(connector); struct edid *edid = NULL; int ret = 0; edid = drm_get_edid(connector, &gma_encoder->i2c_bus->adapter); if (edid) { drm_mode_connector_update_edid_property(connector, edid); ret = drm_add_edid_modes(connector, edid); kfree(edid); } return ret; }
static int CRTConnectorHelperGetModes(struct drm_connector *psConnector) { PVRPSB_CONNECTOR *psPVRConnector = to_pvr_connector(psConnector); struct i2c_adapter *psAdapter = psPVRConnector->psAdapter; struct edid *psEdid; psEdid = drm_get_edid(psConnector, psAdapter); if (psEdid == NULL) { return 0; } drm_mode_connector_update_edid_property(psConnector, psEdid); return drm_add_edid_modes(psConnector, psEdid); }
static int imx_pd_connector_get_modes(struct drm_connector *connector) { struct imx_parallel_display *imxpd = con_to_imxpd(connector); struct device_node *np = imxpd->dev->of_node; int num_modes = 0; if (imxpd->panel && imxpd->panel->funcs && imxpd->panel->funcs->get_modes) { struct drm_display_info *di = &connector->display_info; num_modes = imxpd->panel->funcs->get_modes(imxpd->panel); if (!imxpd->bus_format && di->num_bus_formats) imxpd->bus_format = di->bus_formats[0]; if (num_modes > 0) return num_modes; } if (imxpd->edid) { drm_mode_connector_update_edid_property(connector, imxpd->edid); num_modes = drm_add_edid_modes(connector, imxpd->edid); } if (imxpd->mode_valid) { struct drm_display_mode *mode = drm_mode_create(connector->dev); if (!mode) return -EINVAL; drm_mode_copy(mode, &imxpd->mode); mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED, drm_mode_probed_add(connector, mode); num_modes++; } if (np) { struct drm_display_mode *mode = drm_mode_create(connector->dev); if (!mode) return -EINVAL; of_get_drm_display_mode(np, &imxpd->mode, OF_USE_NATIVE_MODE); drm_mode_copy(mode, &imxpd->mode); mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED, drm_mode_probed_add(connector, mode); num_modes++; } return num_modes; }
/** * intel_ddc_get_modes - get modelist from monitor * @connector: DRM connector device to use * @adapter: i2c adapter * * Fetch the EDID information from @connector using the DDC bus. */ int intel_ddc_get_modes(struct drm_connector *connector, struct i2c_adapter *adapter) { struct edid *edid; int ret = 0; edid = drm_get_edid(connector, adapter); if (edid) { drm_mode_connector_update_edid_property(connector, edid); ret = drm_add_edid_modes(connector, edid); drm_edid_to_eld(connector, edid); connector->display_info.raw_edid = NULL; kfree(edid); } return ret; }
static int edp_connector_get_modes(struct drm_connector *connector) { struct edp_connector *edp_connector = to_edp_connector(connector); struct msm_edp *edp = edp_connector->edp; struct edid *drm_edid = NULL; int ret = 0; DBG(""); ret = msm_edp_ctrl_get_panel_info(edp->ctrl, connector, &drm_edid); if (ret) return ret; drm_mode_connector_update_edid_property(connector, drm_edid); if (drm_edid) ret = drm_add_edid_modes(connector, drm_edid); return ret; }
static int imx_pd_connector_get_modes(struct drm_connector *connector) { struct imx_parallel_display *imxpd = con_to_imxpd(connector); int num_modes = 0; if (imxpd->edid) { drm_mode_connector_update_edid_property(connector, imxpd->edid); num_modes = drm_add_edid_modes(connector, imxpd->edid); } if (imxpd->mode_valid) { struct drm_display_mode *mode = drm_mode_create(connector->dev); drm_mode_copy(mode, &imxpd->mode); mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED, drm_mode_probed_add(connector, mode); num_modes++; } return num_modes; }
static int udl_get_modes(struct drm_connector *connector) { struct udl_device *udl = connector->dev->dev_private; struct edid *edid; int ret; edid = (struct edid *)udl_get_edid(udl); /* * We only read the main block, but if the monitor reports extension * blocks then the drm edid code expects them to be present, so patch * the extension count to 0. */ edid->checksum += edid->extensions; edid->extensions = 0; drm_mode_connector_update_edid_property(connector, edid); ret = drm_add_edid_modes(connector, edid); kfree(edid); return ret; }
static int sun4i_hdmi_get_modes(struct drm_connector *connector) { struct sun4i_hdmi *hdmi = drm_connector_to_sun4i_hdmi(connector); struct edid *edid; int ret; edid = drm_get_edid(connector, hdmi->i2c); if (!edid) return 0; hdmi->hdmi_monitor = drm_detect_hdmi_monitor(edid); DRM_DEBUG_DRIVER("Monitor is %s monitor\n", hdmi->hdmi_monitor ? "an HDMI" : "a DVI"); drm_mode_connector_update_edid_property(connector, edid); cec_s_phys_addr_from_edid(hdmi->cec_adap, edid); ret = drm_add_edid_modes(connector, edid); kfree(edid); return ret; }
int ptn3460_get_modes(struct drm_connector *connector) { struct ptn3460_bridge *ptn_bridge; u8 *edid; int ret, num_modes; bool power_off; ptn_bridge = container_of(connector, struct ptn3460_bridge, connector); if (ptn_bridge->edid) return drm_add_edid_modes(connector, ptn_bridge->edid); power_off = !ptn_bridge->enabled; ptn3460_pre_enable(ptn_bridge->bridge); edid = kmalloc(EDID_LENGTH, GFP_KERNEL); if (!edid) { DRM_ERROR("Failed to allocate edid\n"); return 0; } ret = ptn3460_read_bytes(ptn_bridge, PTN3460_EDID_ADDR, edid, EDID_LENGTH); if (ret) { kfree(edid); num_modes = 0; goto out; } ptn_bridge->edid = (struct edid *)edid; drm_mode_connector_update_edid_property(connector, ptn_bridge->edid); num_modes = drm_add_edid_modes(connector, ptn_bridge->edid); out: if (power_off) ptn3460_disable(ptn_bridge->bridge); return num_modes; }
static int imx_hdmi_connector_get_modes(struct drm_connector *connector) { struct imx_hdmi *hdmi = container_of(connector, struct imx_hdmi, connector); struct edid *edid; int ret; if (!hdmi->ddc) return 0; edid = drm_get_edid(connector, hdmi->ddc); if (edid) { dev_dbg(hdmi->dev, "got edid: width[%d] x height[%d]\n", edid->width_cm, edid->height_cm); drm_mode_connector_update_edid_property(connector, edid); ret = drm_add_edid_modes(connector, edid); kfree(edid); } else { dev_dbg(hdmi->dev, "failed to get edid\n"); } return 0; }
static int imx_ldb_connector_get_modes(struct drm_connector *connector) { struct imx_ldb_channel *imx_ldb_ch = con_to_imx_ldb_ch(connector); int num_modes = 0; if (imx_ldb_ch->panel && imx_ldb_ch->panel->funcs && imx_ldb_ch->panel->funcs->get_modes) { struct drm_display_info *di = &connector->display_info; num_modes = imx_ldb_ch->panel->funcs->get_modes(imx_ldb_ch->panel); if (!imx_ldb_ch->bus_format && di->num_bus_formats) imx_ldb_ch->bus_format = di->bus_formats[0]; if (num_modes > 0) return num_modes; } if (imx_ldb_ch->edid) { drm_mode_connector_update_edid_property(connector, imx_ldb_ch->edid); num_modes = drm_add_edid_modes(connector, imx_ldb_ch->edid); } if (imx_ldb_ch->mode_valid) { struct drm_display_mode *mode; mode = drm_mode_create(connector->dev); if (!mode) return -EINVAL; drm_mode_copy(mode, &imx_ldb_ch->mode); mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(connector, mode); num_modes++; } return num_modes; }
static int hdmi_connector_get_modes(struct drm_connector *connector) { struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector); struct hdmi *hdmi = hdmi_connector->hdmi; struct edid *edid; uint32_t hdmi_ctrl; int ret = 0; hdmi_ctrl = hdmi_read(hdmi, REG_HDMI_CTRL); hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl | HDMI_CTRL_ENABLE); edid = drm_get_edid(connector, hdmi->i2c); hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl); drm_mode_connector_update_edid_property(connector, edid); if (edid) { ret = drm_add_edid_modes(connector, edid); kfree(edid); } return ret; }
static int exynos_drm_connector_get_modes(struct drm_connector *connector) { struct exynos_drm_connector *exynos_connector = to_exynos_connector(connector); struct exynos_drm_manager *manager = exynos_connector->manager; struct exynos_drm_display_ops *display_ops = manager->display_ops; struct edid *edid = NULL; unsigned int count = 0; int ret; if (!display_ops) { DRM_DEBUG_KMS("display_ops is null.\n"); return 0; } /* * if get_edid() exists then get_edid() callback of hdmi side * is called to get edid data through i2c interface else * get timing from the FIMD driver(display controller). * * P.S. in case of lcd panel, count is always 1 if success * because lcd panel has only one mode. */ if (display_ops->get_edid) { edid = display_ops->get_edid(manager->dev, connector); if (IS_ERR_OR_NULL(edid)) { ret = PTR_ERR(edid); edid = NULL; DRM_ERROR("Panel operation get_edid failed %d\n", ret); goto out; } count = drm_add_edid_modes(connector, edid); if (!count) { DRM_ERROR("Add edid modes failed %d\n", count); goto out; } drm_mode_connector_update_edid_property(connector, edid); } else { struct exynos_drm_panel_info *panel; struct drm_display_mode *mode = drm_mode_create(connector->dev); if (!mode) { DRM_ERROR("failed to create a new display mode.\n"); return 0; } if (display_ops->get_panel) panel = display_ops->get_panel(manager->dev); else { drm_mode_destroy(connector->dev, mode); return 0; } convert_to_display_mode(mode, panel); connector->display_info.width_mm = mode->width_mm; connector->display_info.height_mm = mode->height_mm; mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_set_name(mode); drm_mode_probed_add(connector, mode); count = 1; } out: kfree(edid); return count; }
static int exynos_drm_connector_get_modes(struct drm_connector *connector) { struct exynos_drm_connector *exynos_connector = to_exynos_connector(connector); struct exynos_drm_manager *manager = exynos_connector->manager; struct exynos_drm_display_ops *display_ops = manager->display_ops; unsigned int count; DRM_DEBUG_KMS("%s\n", __FILE__); if (!display_ops) { DRM_DEBUG_KMS("display_ops is null.\n"); return 0; } /* * if get_edid() exists then get_edid() callback of hdmi side * is called to get edid data through i2c interface else * get timing from the FIMD driver(display controller). * * P.S. in case of lcd panel, count is always 1 if success * because lcd panel has only one mode. */ if (display_ops->get_edid) { int ret; void *edid; edid = kzalloc(MAX_EDID, GFP_KERNEL); if (!edid) { DRM_ERROR("failed to allocate edid\n"); return 0; } ret = display_ops->get_edid(manager->dev, connector, edid, MAX_EDID); if (ret < 0) { DRM_ERROR("failed to get edid data.\n"); kfree(edid); edid = NULL; return 0; } drm_mode_connector_update_edid_property(connector, edid); count = drm_add_edid_modes(connector, edid); kfree(connector->display_info.raw_edid); connector->display_info.raw_edid = edid; } else { struct drm_display_mode *mode = drm_mode_create(connector->dev); struct fb_videomode *timing; if (display_ops->get_timing) timing = display_ops->get_timing(manager->dev); else { drm_mode_destroy(connector->dev, mode); return 0; } convert_to_display_mode(mode, timing); mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_set_name(mode); drm_mode_probed_add(connector, mode); count = 1; } return count; }