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->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++; } if (np) { struct drm_display_mode *mode = drm_mode_create(connector->dev); 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; }
/** * add_detailed_modes - get detailed mode info from EDID data * @edid: EDID block to scan * * Some of the detailed timing sections may contain mode information. Grab * it and add it to the list. */ static int add_detailed_info(struct drm_output *output, struct edid *edid) { struct drm_device *dev = output->dev; int i, j, modes = 0; for (i = 0; i < EDID_DETAILED_TIMINGS; i++) { struct detailed_timing *timing = &edid->detailed_timings[i]; struct detailed_non_pixel *data = &timing->data.other_data; struct drm_display_mode *newmode; /* EDID up to and including 1.2 may put monitor info here */ if (edid->version == 1 && edid->revision < 3) continue; /* Detailed mode timing */ if (timing->pixel_clock) { newmode = drm_mode_detailed(dev, timing); /* First detailed mode is preferred */ if (i == 0 && edid->preferred_timing) newmode->type |= DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(output, newmode); modes++; continue; } /* Other timing or info */ switch (data->type) { case EDID_DETAIL_MONITOR_SERIAL: break; case EDID_DETAIL_MONITOR_STRING: break; case EDID_DETAIL_MONITOR_RANGE: /* Get monitor range data */ break; case EDID_DETAIL_MONITOR_NAME: break; case EDID_DETAIL_MONITOR_CPDATA: break; case EDID_DETAIL_STD_MODES: /* Five modes per detailed section */ for (j = 0; j < 5; i++) { struct std_timing *std; struct drm_display_mode *newmode; std = &data->data.timings[j]; newmode = drm_mode_std(dev, std); drm_mode_probed_add(output, newmode); modes++; } break; default: break; } } return modes; }
static int exynos_dp_get_modes(struct drm_connector *connector) { struct exynos_dp_device *dp = ctx_from_connector(connector); struct drm_display_mode *mode; if (dp->panel) return drm_panel_get_modes(dp->panel); mode = drm_mode_create(connector->dev); if (!mode) { DRM_ERROR("failed to create a new display mode.\n"); return 0; } drm_display_mode_from_videomode(&dp->priv.vm, mode); mode->width_mm = dp->priv.width_mm; mode->height_mm = dp->priv.height_mm; 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); return 1; }
static int meson_connector_get_modes(struct drm_connector *connector) { struct meson_connector *meson_connector = to_meson_connector(connector); struct drm_device *dev = connector->dev; drm_mode_probed_add(connector, drm_mode_duplicate(dev, meson_connector->mode)); return 1; }
static int exynos_dp_get_modes(struct analogix_dp_plat_data *plat_data) { struct exynos_dp_device *dp = to_dp(plat_data); struct drm_connector *connector = &dp->connector; struct drm_display_mode *mode; int num_modes = 0; if (dp->plat_data.panel) return num_modes; mode = drm_mode_create(connector->dev); if (!mode) { DRM_ERROR("failed to create a new display mode.\n"); return num_modes; } drm_display_mode_from_videomode(&dp->vm, mode); 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); return num_modes + 1; }
static int dce_virtual_get_modes(struct drm_connector *connector) { struct drm_device *dev = connector->dev; struct drm_display_mode *mode = NULL; unsigned i; static const struct mode_size { int w; int h; } common_modes[17] = { { 640, 480}, { 720, 480}, { 800, 600}, { 848, 480}, {1024, 768}, {1152, 768}, {1280, 720}, {1280, 800}, {1280, 854}, {1280, 960}, {1280, 1024}, {1440, 900}, {1400, 1050}, {1680, 1050}, {1600, 1200}, {1920, 1080}, {1920, 1200} }; for (i = 0; i < 17; i++) { mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false); drm_mode_probed_add(connector, mode); } 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) { num_modes = imx_ldb_ch->panel->funcs->get_modes(imx_ldb_ch->panel); 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 panel_connector_get_modes(struct drm_connector *connector) { struct drm_device *dev = connector->dev; struct panel_connector *panel_connector = to_panel_connector(connector); struct display_timings *timings = panel_connector->mod->timings; int i; for (i = 0; i < timings->num_timings; i++) { struct drm_display_mode *mode = drm_mode_create(dev); struct videomode vm; if (videomode_from_timings(timings, &vm, i)) break; drm_display_mode_from_videomode(&vm, mode); mode->type = DRM_MODE_TYPE_DRIVER; if (timings->native_mode == i) mode->type |= DRM_MODE_TYPE_PREFERRED; drm_mode_set_name(mode); drm_mode_probed_add(connector, mode); } return i; }
static int shmob_drm_connector_get_modes(struct drm_connector *connector) { struct shmob_drm_device *sdev = connector->dev->dev_private; struct drm_display_mode *mode; mode = drm_mode_create(connector->dev); if (mode == NULL) return 0; mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER; mode->clock = sdev->pdata->panel.mode.clock; mode->hdisplay = sdev->pdata->panel.mode.hdisplay; mode->hsync_start = sdev->pdata->panel.mode.hsync_start; mode->hsync_end = sdev->pdata->panel.mode.hsync_end; mode->htotal = sdev->pdata->panel.mode.htotal; mode->vdisplay = sdev->pdata->panel.mode.vdisplay; mode->vsync_start = sdev->pdata->panel.mode.vsync_start; mode->vsync_end = sdev->pdata->panel.mode.vsync_end; mode->vtotal = sdev->pdata->panel.mode.vtotal; mode->flags = sdev->pdata->panel.mode.flags; drm_mode_set_name(mode); drm_mode_probed_add(connector, mode); connector->display_info.width_mm = sdev->pdata->panel.width_mm; connector->display_info.height_mm = sdev->pdata->panel.height_mm; return 1; }
static int intel_dsi_get_modes(struct drm_connector *connector) { struct intel_connector *intel_connector = to_intel_connector(connector); struct intel_dsi *intel_dsi = intel_attached_dsi(connector); struct drm_display_mode *mode; struct drm_display_mode *input_mode = NULL; DRM_DEBUG_KMS("\n"); if (!intel_connector->panel.fixed_mode) { DRM_DEBUG_KMS("no fixed mode\n"); return 0; } input_mode = intel_connector->panel.fixed_mode; mode = drm_mode_duplicate(connector->dev, input_mode); if (!mode) { DRM_DEBUG_KMS("drm_mode_duplicate failed\n"); return 0; } drm_mode_probed_add(connector, mode); /*Fill the panel info here*/ intel_dsi->dev.dev_ops->get_info(0, connector); return 1; }
static int virtio_gpu_conn_get_modes(struct drm_connector *connector) { struct virtio_gpu_output *output = drm_connector_to_virtio_gpu_output(connector); struct drm_display_mode *mode = NULL; int count, width, height; width = le32_to_cpu(output->info.r.width); height = le32_to_cpu(output->info.r.height); count = drm_add_modes_noedid(connector, XRES_MAX, YRES_MAX); if (width == 0 || height == 0) { width = XRES_DEF; height = YRES_DEF; drm_set_preferred_mode(connector, XRES_DEF, YRES_DEF); } else { DRM_DEBUG("add mode: %dx%d\n", width, height); mode = drm_cvt_mode(connector->dev, width, height, 60, false, false, false); mode->type |= DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(connector, mode); count++; } return count; }
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; }
static int omap_connector_get_modes(struct drm_connector *connector) { struct omap_connector *omap_connector = to_omap_connector(connector); struct omap_dss_device *dssdev = omap_connector->dssdev; struct omap_dss_driver *dssdrv = dssdev->driver; struct drm_device *dev = connector->dev; int n = 0; DBG("%s", omap_connector->dssdev->name); /* if display exposes EDID, then we parse that in the normal way to * build table of supported modes.. otherwise (ie. fixed resolution * LCD panels) we just return a single mode corresponding to the * currently configured timings: */ if (dssdrv->read_edid) { void *edid = kzalloc(MAX_EDID, GFP_KERNEL); if ((dssdrv->read_edid(dssdev, edid, MAX_EDID) > 0) && drm_edid_is_valid(edid)) { drm_mode_connector_update_edid_property( connector, edid); n = drm_add_edid_modes(connector, edid); omap_connector->hdmi_mode = drm_detect_hdmi_monitor(edid); } else { drm_mode_connector_update_edid_property( connector, NULL); } kfree(edid); } else { struct drm_display_mode *mode = drm_mode_create(dev); struct videomode vm = {0}; dssdrv->get_timings(dssdev, &vm); drm_display_mode_from_videomode(&vm, mode); mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_set_name(mode); drm_mode_probed_add(connector, mode); n = 1; } return n; }
static int jzdrm_connector_get_modes(struct drm_connector *connector) { struct lcd_link *lcd_link = container_of(connector, struct lcd_link, connector); struct drm_display_mode *mode = drm_mode_create(connector->dev); int n; get_previous_mode(mode, lcd_link); mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_set_name(mode); drm_mode_probed_add(connector, mode); n = 1; return n; }
/** * add_established_modes - get est. modes from EDID and add them * @edid: EDID block to scan * * Each EDID block contains a bitmap of the supported "established modes" list * (defined above). Tease them out and add them to the global modes list. */ static int add_established_modes(struct drm_output *output, struct edid *edid) { struct drm_device *dev = output->dev; unsigned long est_bits = edid->established_timings.t1 | (edid->established_timings.t2 << 8) | ((edid->established_timings.mfg_rsvd & 0x80) << 9); int i, modes = 0; for (i = 0; i <= EDID_EST_TIMINGS; i++) if (est_bits & (1<<i)) { struct drm_display_mode *newmode; newmode = drm_mode_duplicate(dev, &edid_est_modes[i]); drm_mode_probed_add(output, newmode); modes++; } return modes; }
static int rcar_du_lvds_connector_get_modes(struct drm_connector *connector) { struct rcar_du_lvds_connector *lvdscon = to_rcar_lvds_connector(connector); struct drm_display_mode *mode; mode = drm_mode_create(connector->dev); if (mode == NULL) return 0; mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER; drm_display_mode_from_videomode(&lvdscon->panel.mode, mode); drm_mode_probed_add(connector, mode); return 1; }
static int omap_connector_get_modes(struct drm_connector *connector) { struct omap_connector *omap_connector = to_omap_connector(connector); struct omap_dss_device *dssdev = omap_connector->dssdev; struct omap_dss_driver *dssdrv = dssdev->driver; struct drm_device *dev = connector->dev; int n = 0; DBG("%s", omap_connector->dssdev->name); if (dssdrv->read_edid) { void *edid = kzalloc(MAX_EDID, GFP_KERNEL); if ((dssdrv->read_edid(dssdev, edid, MAX_EDID) > 0) && drm_edid_is_valid(edid)) { drm_mode_connector_update_edid_property( connector, edid); n = drm_add_edid_modes(connector, edid); kfree(connector->display_info.raw_edid); connector->display_info.raw_edid = edid; } else { drm_mode_connector_update_edid_property( connector, NULL); connector->display_info.raw_edid = NULL; kfree(edid); } } else { struct drm_display_mode *mode = drm_mode_create(dev); struct omap_video_timings timings; dssdrv->get_timings(dssdev, &timings); copy_timings_omap_to_drm(mode, &timings); mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_set_name(mode); drm_mode_probed_add(connector, mode); n = 1; } return n; }
static int qxl_add_monitors_config_modes(struct drm_connector *connector) { struct drm_device *dev = connector->dev; struct qxl_device *qdev = dev->dev_private; struct qxl_output *output = drm_connector_to_qxl_output(connector); int h = output->index; struct drm_display_mode *mode = NULL; struct qxl_head *head; if (!qdev->client_monitors_config) return 0; head = &qdev->client_monitors_config->heads[h]; mode = drm_cvt_mode(dev, head->width, head->height, 60, false, false, false); mode->type |= DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(connector, mode); return 1; }
static int ch7006_encoder_get_modes(struct drm_encoder *encoder, struct drm_connector *connector) { struct ch7006_priv *priv = to_ch7006_priv(encoder); struct ch7006_mode *mode; int n = 0; for (mode = ch7006_modes; mode->mode.clock; mode++) { if (~mode->valid_scales & 1<<priv->scale || ~mode->valid_norms & 1<<priv->norm) continue; drm_mode_probed_add(connector, drm_mode_duplicate(encoder->dev, &mode->mode)); n++; } return n; }
/** * add_standard_modes - get std. modes from EDID and add them * @edid: EDID block to scan * * Standard modes can be calculated using the CVT standard. Grab them from * @edid, calculate them, and add them to the list. */ static int add_standard_modes(struct drm_output *output, struct edid *edid) { struct drm_device *dev = output->dev; int i, modes = 0; for (i = 0; i < EDID_STD_TIMINGS; i++) { struct std_timing *t = &edid->standard_timings[i]; struct drm_display_mode *newmode; /* If std timings bytes are 1, 1 it's empty */ if (t->hsize == 1 && (t->aspect_ratio | t->vfreq) == 1) continue; newmode = drm_mode_std(dev, &edid->standard_timings[i]); drm_mode_probed_add(output, newmode); modes++; } return modes; }
static int qxl_add_common_modes(struct drm_connector *connector) { struct drm_device *dev = connector->dev; struct drm_display_mode *mode = NULL; int i; struct mode_size { int w; int h; } common_modes[] = { { 640, 480}, { 720, 480}, { 800, 600}, { 848, 480}, {1024, 768}, {1152, 768}, {1280, 720}, {1280, 800}, {1280, 854}, {1280, 960}, {1280, 1024}, {1440, 900}, {1400, 1050}, {1680, 1050}, {1600, 1200}, {1920, 1080}, {1920, 1200} }; for (i = 0; i < ARRAY_SIZE(common_modes); i++) { if (common_modes[i].w < 320 || common_modes[i].h < 200) continue; mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false); if (common_modes[i].w == 1024 && common_modes[i].h == 768) mode->type |= DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(connector, mode); } return i - 1; }
static int intel_dsi_get_modes(struct drm_connector *connector) { struct intel_connector *intel_connector = to_intel_connector(connector); struct drm_display_mode *mode; DRM_DEBUG_KMS("\n"); if (!intel_connector->panel.fixed_mode) { DRM_DEBUG_KMS("no fixed mode\n"); return 0; } mode = drm_mode_duplicate(connector->dev, intel_connector->panel.fixed_mode); if (!mode) { DRM_DEBUG_KMS("drm_mode_duplicate failed\n"); return 0; } drm_mode_probed_add(connector, mode); return 1; }
static int vbox_get_modes(struct drm_connector *pConnector) { struct vbox_connector *pVBoxConnector = NULL; struct drm_display_mode *pMode = NULL; unsigned cModes = 0; LogFunc(("vboxvideo: %d: pConnector=%p\n", __LINE__, pConnector)); pVBoxConnector = to_vbox_connector(pConnector); cModes = drm_add_modes_noedid(pConnector, 1024, 768); if (pVBoxConnector->modeHint.cX && pVBoxConnector->modeHint.cY) { pMode = drm_cvt_mode(pConnector->dev, pVBoxConnector->modeHint.cX, pVBoxConnector->modeHint.cY, 60, false, false, false); if (pMode) { pMode->type |= DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(pConnector, pMode); ++cModes; } } return cModes; }
static int s6e8aa0_get_modes(struct drm_panel *panel) { struct drm_connector *connector = panel->connector; struct s6e8aa0 *ctx = panel_to_s6e8aa0(panel); struct drm_display_mode *mode; mode = drm_mode_create(connector->dev); if (!mode) { DRM_ERROR("failed to create a new display mode\n"); return 0; } drm_display_mode_from_videomode(&ctx->vm, mode); mode->width_mm = ctx->width_mm; mode->height_mm = ctx->height_mm; 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_probed_add(connector, mode); return 1; }
static int exynos_dpi_get_modes(struct drm_connector *connector) { struct exynos_dpi *ctx = connector_to_dpi(connector); /* fimd timings gets precedence over panel modes */ if (ctx->vm) { struct drm_display_mode *mode; mode = drm_mode_create(connector->dev); if (!mode) { DRM_ERROR("failed to create a new display mode\n"); return 0; } drm_display_mode_from_videomode(ctx->vm, mode); mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(connector, mode); return 1; } if (ctx->panel) return ctx->panel->funcs->get_modes(ctx->panel); return 0; }
static int s6e3ha2_get_modes(struct drm_panel *panel) { struct drm_connector *connector = panel->connector; struct s6e3ha2 *ctx = container_of(panel, struct s6e3ha2, panel); struct drm_display_mode *mode; mode = drm_mode_duplicate(panel->drm, ctx->desc->mode); if (!mode) { DRM_ERROR("failed to add mode %ux%ux@%u\n", ctx->desc->mode->hdisplay, ctx->desc->mode->vdisplay, ctx->desc->mode->vrefresh); return -ENOMEM; } drm_mode_set_name(mode); mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; drm_mode_probed_add(connector, mode); connector->display_info.width_mm = 71; connector->display_info.height_mm = 125; return 1; }
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; }
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; }