Lines Matching defs:connector
96 struct drm_connector *connector;
2198 static void connector_bad_edid(struct drm_connector *connector,
2214 connector->real_edid_checksum =
2217 if (connector->bad_edid_counter++ && !drm_debug_enabled(DRM_UT_KMS))
2220 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID is invalid:\n",
2221 connector->base.id, connector->name);
2227 static const struct drm_edid *drm_edid_override_get(struct drm_connector *connector)
2231 mutex_lock(&connector->edid_override_mutex);
2233 if (connector->edid_override)
2234 override = drm_edid_dup(connector->edid_override);
2236 mutex_unlock(&connector->edid_override_mutex);
2239 override = drm_edid_load_firmware(connector);
2245 int drm_edid_override_show(struct drm_connector *connector, struct seq_file *m)
2249 mutex_lock(&connector->edid_override_mutex);
2251 drm_edid = connector->edid_override;
2255 mutex_unlock(&connector->edid_override_mutex);
2261 int drm_edid_override_set(struct drm_connector *connector, const void *edid,
2268 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID override invalid\n",
2269 connector->base.id, connector->name);
2274 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID override set\n",
2275 connector->base.id, connector->name);
2277 mutex_lock(&connector->edid_override_mutex);
2279 drm_edid_free(connector->edid_override);
2280 connector->edid_override = drm_edid;
2282 mutex_unlock(&connector->edid_override_mutex);
2288 int drm_edid_override_reset(struct drm_connector *connector)
2290 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID override reset\n",
2291 connector->base.id, connector->name);
2293 mutex_lock(&connector->edid_override_mutex);
2295 drm_edid_free(connector->edid_override);
2296 connector->edid_override = NULL;
2298 mutex_unlock(&connector->edid_override_mutex);
2305 * @connector: connector we're probing
2314 int drm_edid_override_connector_update(struct drm_connector *connector)
2319 override = drm_edid_override_get(connector);
2321 if (drm_edid_connector_update(connector, override) == 0)
2322 num_modes = drm_edid_connector_add_modes(connector);
2326 drm_dbg_kms(connector->dev,
2328 connector->base.id, connector->name, num_modes);
2370 static struct edid *_drm_do_get_edid(struct drm_connector *connector,
2380 override = drm_edid_override_get(connector);
2403 connector->edid_corrupt = false;
2405 connector->edid_corrupt = true;
2409 connector->null_edid_counter++;
2411 connector_bad_edid(connector, edid, 1);
2476 connector_bad_edid(connector, edid, num_blocks);
2494 * @connector: connector we're probing
2512 struct edid *drm_do_get_edid(struct drm_connector *connector,
2516 return _drm_do_get_edid(connector, read_block, context, NULL);
2644 * @connector: connector we're probing
2648 * attach it to the connector.
2652 struct edid *drm_get_edid(struct drm_connector *connector,
2657 if (connector->force == DRM_FORCE_OFF)
2660 if (connector->force == DRM_FORCE_UNSPECIFIED && !drm_probe_ddc(adapter))
2663 edid = _drm_do_get_edid(connector, drm_do_probe_ddc_edid, adapter, NULL);
2664 drm_connector_update_edid_property(connector, edid);
2671 * @connector: Connector to use
2692 const struct drm_edid *drm_edid_read_custom(struct drm_connector *connector,
2700 edid = _drm_do_get_edid(connector, read_block, context, &size);
2705 drm_WARN_ON(connector->dev, !size);
2717 * @connector: Connector to use
2726 * Prefer initializing connector->ddc with drm_connector_init_with_ddc() and
2733 const struct drm_edid *drm_edid_read_ddc(struct drm_connector *connector,
2738 if (connector->force == DRM_FORCE_OFF)
2741 if (connector->force == DRM_FORCE_UNSPECIFIED && !drm_probe_ddc(adapter))
2744 drm_edid = drm_edid_read_custom(connector, drm_do_probe_ddc_edid, adapter);
2746 /* Note: Do *not* call connector updates here. */
2753 * drm_edid_read - Read EDID data using connector's I2C adapter
2754 * @connector: Connector to use
2756 * Read EDID using the connector's I2C adapter.
2766 const struct drm_edid *drm_edid_read(struct drm_connector *connector)
2768 if (drm_WARN_ON(connector->dev, !connector->ddc))
2771 return drm_edid_read_ddc(connector, connector->ddc);
2851 * @connector: connector we're probing
2860 struct edid *drm_get_edid_switcheroo(struct drm_connector *connector,
2866 struct drm_device *dev = connector->dev;
2874 edid = drm_get_edid(connector, adapter);
2884 * @connector: connector we're probing
2893 const struct drm_edid *drm_edid_read_switcheroo(struct drm_connector *connector,
2899 struct drm_device *dev = connector->dev;
2907 drm_edid = drm_edid_read_ddc(connector, adapter);
2957 * Walk the mode list for connector, clearing the preferred status on existing
2960 static void edid_fixup_preferred(struct drm_connector *connector)
2962 const struct drm_display_info *info = &connector->display_info;
2967 if (list_empty(&connector->probed_modes))
2975 preferred_mode = list_first_entry(&connector->probed_modes,
2978 list_for_each_entry_safe(cur_mode, t, &connector->probed_modes, head) {
3331 static struct drm_display_mode *drm_mode_std(struct drm_connector *connector,
3335 struct drm_device *dev = connector->dev;
3374 * If this connector already has a mode for this size and refresh
3379 list_for_each_entry(m, &connector->probed_modes, head)
3472 static struct drm_display_mode *drm_mode_detailed(struct drm_connector *connector,
3476 const struct drm_display_info *info = &connector->display_info;
3477 struct drm_device *dev = connector->dev;
3495 connector->base.id, connector->name);
3500 connector->base.id, connector->name);
3506 connector->base.id, connector->name);
3540 connector->base.id, connector->name,
3546 connector->base.id, connector->name,
3660 static bool valid_inferred_mode(const struct drm_connector *connector,
3666 list_for_each_entry(m, &connector->probed_modes, head) {
3678 static int drm_dmt_modes_for_range(struct drm_connector *connector,
3684 struct drm_device *dev = connector->dev;
3688 valid_inferred_mode(connector, drm_dmt_modes + i)) {
3691 drm_mode_probed_add(connector, newmode);
3713 static int drm_gtf_modes_for_range(struct drm_connector *connector,
3719 struct drm_device *dev = connector->dev;
3730 !valid_inferred_mode(connector, newmode)) {
3735 drm_mode_probed_add(connector, newmode);
3742 static int drm_gtf2_modes_for_range(struct drm_connector *connector,
3748 struct drm_device *dev = connector->dev;
3759 !valid_inferred_mode(connector, newmode)) {
3764 drm_mode_probed_add(connector, newmode);
3771 static int drm_cvt_modes_for_range(struct drm_connector *connector,
3777 struct drm_device *dev = connector->dev;
3789 !valid_inferred_mode(connector, newmode)) {
3794 drm_mode_probed_add(connector, newmode);
3811 closure->modes += drm_dmt_modes_for_range(closure->connector,
3820 closure->modes += drm_gtf2_modes_for_range(closure->connector,
3825 closure->modes += drm_gtf_modes_for_range(closure->connector,
3833 closure->modes += drm_cvt_modes_for_range(closure->connector,
3843 static int add_inferred_modes(struct drm_connector *connector,
3847 .connector = connector,
3858 drm_est3_modes(struct drm_connector *connector, const struct detailed_timing *timing)
3870 mode = drm_mode_find_dmt(connector->dev,
3876 drm_mode_probed_add(connector, mode);
3894 closure->modes += drm_est3_modes(closure->connector, timing);
3902 static int add_established_modes(struct drm_connector *connector,
3905 struct drm_device *dev = connector->dev;
3912 .connector = connector,
3922 drm_mode_probed_add(connector, newmode);
3940 struct drm_connector *connector = closure->connector;
3950 newmode = drm_mode_std(connector, closure->drm_edid, std);
3952 drm_mode_probed_add(connector, newmode);
3963 static int add_standard_modes(struct drm_connector *connector,
3968 .connector = connector,
3975 newmode = drm_mode_std(connector, drm_edid,
3978 drm_mode_probed_add(connector, newmode);
3992 static int drm_cvt_modes(struct drm_connector *connector,
3997 struct drm_device *dev = connector->dev;
4034 drm_mode_probed_add(connector, newmode);
4052 closure->modes += drm_cvt_modes(closure->connector, timing);
4056 add_cvt_modes(struct drm_connector *connector, const struct drm_edid *drm_edid)
4059 .connector = connector,
4071 static void fixup_detailed_cea_mode_clock(struct drm_connector *connector,
4083 newmode = drm_mode_detailed(closure->connector,
4096 fixup_detailed_cea_mode_clock(closure->connector, newmode);
4098 drm_mode_probed_add(closure->connector, newmode);
4105 * @connector: attached connector
4108 static int add_detailed_modes(struct drm_connector *connector,
4112 .connector = connector,
4467 static int add_alternate_cea_modes(struct drm_connector *connector,
4470 struct drm_device *dev = connector->dev;
4483 list_for_each_entry(mode, &connector->probed_modes, head) {
4532 drm_mode_probed_add(connector, mode);
4553 drm_display_mode_from_vic_index(struct drm_connector *connector, int vic_index)
4555 const struct drm_display_info *info = &connector->display_info;
4556 struct drm_device *dev = connector->dev;
4566 * @connector: connector corresponding to the HDMI sink
4574 static int do_y420vdb_modes(struct drm_connector *connector,
4577 struct drm_device *dev = connector->dev;
4590 drm_mode_probed_add(connector, newmode);
4626 static int add_cta_vdb_modes(struct drm_connector *connector)
4628 const struct drm_display_info *info = &connector->display_info;
4637 mode = drm_display_mode_from_vic_index(connector, i);
4639 drm_mode_probed_add(connector, mode);
4677 static int add_hdmi_mandatory_stereo_modes(struct drm_connector *connector)
4679 struct drm_device *dev = connector->dev;
4686 list_for_each_entry(mode, &connector->probed_modes, head) {
4706 list_splice_tail(&stereo_modes, &connector->probed_modes);
4711 static int add_hdmi_mode(struct drm_connector *connector, u8 vic)
4713 struct drm_device *dev = connector->dev;
4717 drm_err(connector->dev, "[CONNECTOR:%d:%s] Unknown HDMI VIC: %d\n",
4718 connector->base.id, connector->name, vic);
4726 drm_mode_probed_add(connector, newmode);
4731 static int add_3d_struct_modes(struct drm_connector *connector, u16 structure,
4738 newmode = drm_display_mode_from_vic_index(connector, vic_index);
4741 drm_mode_probed_add(connector, newmode);
4746 newmode = drm_display_mode_from_vic_index(connector, vic_index);
4749 drm_mode_probed_add(connector, newmode);
4754 newmode = drm_display_mode_from_vic_index(connector, vic_index);
4757 drm_mode_probed_add(connector, newmode);
4787 * @connector: connector corresponding to the HDMI sink
4791 * Parses the HDMI VSDB looking for modes to add to @connector. This function
4795 do_hdmi_vsdb_modes(struct drm_connector *connector, const u8 *db, u8 len)
4819 modes += add_hdmi_mandatory_stereo_modes(connector);
4833 modes += add_hdmi_mode(connector, vic);
4862 modes += add_3d_struct_modes(connector,
4899 newmode = drm_display_mode_from_vic_index(connector,
4904 drm_mode_probed_add(connector, newmode);
5251 static void parse_cta_y420cmdb(struct drm_connector *connector,
5254 struct drm_display_info *info = &connector->display_info;
5290 static int add_cea_modes(struct drm_connector *connector,
5298 modes = add_cta_vdb_modes(connector);
5303 modes += do_hdmi_vsdb_modes(connector, (const u8 *)db,
5309 modes += do_y420vdb_modes(connector, vdb420,
5318 static void fixup_detailed_cea_mode_clock(struct drm_connector *connector,
5357 drm_dbg_kms(connector->dev,
5359 connector->base.id, connector->name,
5364 static void drm_calculate_luminance_range(struct drm_connector *connector)
5366 struct hdr_static_metadata *hdr_metadata = &connector->hdr_sink_metadata.hdmi_type1;
5368 &connector->display_info.luminance_range;
5425 drm_parse_hdr_metadata_block(struct drm_connector *connector, const u8 *db)
5431 connector->hdr_sink_metadata.hdmi_type1.eotf =
5433 connector->hdr_sink_metadata.hdmi_type1.metadata_type =
5437 connector->hdr_sink_metadata.hdmi_type1.max_cll = db[4];
5439 connector->hdr_sink_metadata.hdmi_type1.max_fall = db[5];
5441 connector->hdr_sink_metadata.hdmi_type1.min_cll = db[6];
5444 drm_calculate_luminance_range(connector);
5450 drm_parse_hdmi_vsdb_audio(struct drm_connector *connector, const u8 *db)
5455 connector->eld[DRM_ELD_SAD_COUNT_CONN_TYPE] |= DRM_ELD_SUPPORTS_AI;
5458 connector->latency_present[0] = true;
5459 connector->video_latency[0] = db[9];
5460 connector->audio_latency[0] = db[10];
5464 connector->latency_present[1] = true;
5465 connector->video_latency[1] = db[11];
5466 connector->audio_latency[1] = db[12];
5469 drm_dbg_kms(connector->dev,
5471 connector->base.id, connector->name,
5472 connector->latency_present[0], connector->latency_present[1],
5473 connector->video_latency[0], connector->video_latency[1],
5474 connector->audio_latency[0], connector->audio_latency[1]);
5536 static void clear_eld(struct drm_connector *connector)
5538 memset(connector->eld, 0, sizeof(connector->eld));
5540 connector->latency_present[0] = false;
5541 connector->latency_present[1] = false;
5542 connector->video_latency[0] = 0;
5543 connector->audio_latency[0] = 0;
5544 connector->video_latency[1] = 0;
5545 connector->audio_latency[1] = 0;
5550 * @connector: connector corresponding to the HDMI/DP sink
5556 static void drm_edid_to_eld(struct drm_connector *connector,
5559 const struct drm_display_info *info = &connector->display_info;
5562 uint8_t *eld = connector->eld;
5570 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] ELD monitor %s\n",
5571 connector->base.id, connector->name,
5607 drm_parse_hdmi_vsdb_audio(connector, (const u8 *)db);
5617 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
5618 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
5626 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] ELD size %d, SAD count %d\n",
5627 connector->base.id, connector->name,
5733 * @connector: connector associated with the HDMI/DP sink
5739 int drm_av_sync_delay(struct drm_connector *connector,
5745 if (!connector->latency_present[0])
5747 if (!connector->latency_present[1])
5750 a = connector->audio_latency[i];
5751 v = connector->video_latency[i];
5896 static void parse_cta_vdb(struct drm_connector *connector, const struct cea_db *db)
5898 struct drm_display_info *info = &connector->display_info;
5939 static void update_cta_y420cmdb(struct drm_connector *connector, u64 y420cmdb_map)
5941 struct drm_display_info *info = &connector->display_info;
5953 static bool cta_vdb_has_vic(const struct drm_connector *connector, u8 vic)
5955 const struct drm_display_info *info = &connector->display_info;
5970 static void parse_cta_y420vdb(struct drm_connector *connector,
5973 struct drm_display_info *info = &connector->display_info;
5989 static void drm_parse_vcdb(struct drm_connector *connector, const u8 *db)
5991 struct drm_display_info *info = &connector->display_info;
5993 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] CEA VCDB 0x%02x\n",
5994 connector->base.id, connector->name, db[2]);
6035 static void drm_parse_ycbcr420_deep_color_info(struct drm_connector *connector,
6039 struct drm_hdmi_info *hdmi = &connector->display_info.hdmi;
6117 static void drm_parse_hdmi_forum_scds(struct drm_connector *connector,
6120 struct drm_display_info *info = &connector->display_info;
6169 drm_parse_ycbcr420_deep_color_info(connector, hf_scds);
6176 drm_dbg_kms(connector->dev,
6178 connector->base.id, connector->name,
6182 static void drm_parse_hdmi_deep_color_info(struct drm_connector *connector,
6185 struct drm_display_info *info = &connector->display_info;
6197 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does deep color 30.\n",
6198 connector->base.id, connector->name);
6204 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does deep color 36.\n",
6205 connector->base.id, connector->name);
6211 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does deep color 48.\n",
6212 connector->base.id, connector->name);
6216 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] No deep color support on this HDMI sink.\n",
6217 connector->base.id, connector->name);
6221 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] Assigning HDMI sink color depth as %d bpc.\n",
6222 connector->base.id, connector->name, dc_bpc);
6228 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does YCRCB444 in deep color.\n",
6229 connector->base.id, connector->name);
6237 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink should do DC_36, but does not!\n",
6238 connector->base.id, connector->name);
6244 drm_parse_hdmi_vsdb_video(struct drm_connector *connector, const u8 *db)
6246 struct drm_display_info *info = &connector->display_info;
6265 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI: DVI dual %d, max TMDS clock %d kHz\n",
6266 connector->base.id, connector->name,
6269 drm_parse_hdmi_deep_color_info(connector, db);
6276 static void drm_parse_microsoft_vsdb(struct drm_connector *connector,
6279 struct drm_display_info *info = &connector->display_info;
6287 drm_dbg_kms(connector->dev,
6289 connector->base.id, connector->name, version, db[5]);
6292 static void drm_parse_cea_ext(struct drm_connector *connector,
6295 struct drm_display_info *info = &connector->display_info;
6311 drm_dbg_kms(connector->dev,
6313 connector->base.id, connector->name,
6334 drm_parse_hdmi_vsdb_video(connector, data);
6337 drm_parse_hdmi_forum_scds(connector, data);
6339 drm_parse_microsoft_vsdb(connector, data);
6341 parse_cta_y420cmdb(connector, db, &y420cmdb_map);
6343 parse_cta_y420vdb(connector, db);
6345 drm_parse_vcdb(connector, data);
6347 drm_parse_hdr_metadata_block(connector, data);
6349 parse_cta_vdb(connector, db);
6356 update_cta_y420cmdb(connector, y420cmdb_map);
6363 struct drm_display_info *info = &closure->connector->display_info;
6395 static void drm_get_monitor_range(struct drm_connector *connector,
6398 const struct drm_display_info *info = &connector->display_info;
6400 .connector = connector,
6412 drm_dbg_kms(connector->dev,
6414 connector->base.id, connector->name,
6418 static void drm_parse_vesa_mso_data(struct drm_connector *connector,
6423 struct drm_display_info *info = &connector->display_info;
6426 drm_dbg_kms(connector->dev,
6428 connector->base.id, connector->name, block->num_bytes);
6436 drm_dbg_kms(connector->dev,
6438 connector->base.id, connector->name);
6444 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] Reserved MSO mode value\n",
6445 connector->base.id, connector->name);
6465 drm_dbg_kms(connector->dev,
6467 connector->base.id, connector->name,
6472 drm_dbg_kms(connector->dev,
6474 connector->base.id, connector->name,
6478 static void drm_update_mso(struct drm_connector *connector,
6487 drm_parse_vesa_mso_data(connector, block);
6492 /* A connector has no EDID information, so we've got no EDID to compute quirks from. Reset
6495 static void drm_reset_display_info(struct drm_connector *connector)
6497 struct drm_display_info *info = &connector->display_info;
6531 static void update_displayid_info(struct drm_connector *connector,
6534 struct drm_display_info *info = &connector->display_info;
6554 static void update_display_info(struct drm_connector *connector,
6557 struct drm_display_info *info = &connector->display_info;
6560 drm_reset_display_info(connector);
6561 clear_eld(connector);
6573 drm_get_monitor_range(connector, drm_edid);
6582 drm_parse_cea_ext(connector, drm_edid);
6584 update_displayid_info(connector, drm_edid);
6596 drm_dbg_kms(connector->dev,
6598 connector->base.id, connector->name, info->bpc);
6630 drm_dbg_kms(connector->dev,
6632 connector->base.id, connector->name, info->bpc);
6639 drm_update_mso(connector, drm_edid);
6643 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] Non-desktop display%s\n",
6644 connector->base.id, connector->name,
6665 drm_edid_to_eld(connector, drm_edid);
6715 static int add_displayid_detailed_1_modes(struct drm_connector *connector,
6732 newmode = drm_mode_displayid_detailed(connector->dev, timings, type_7);
6736 drm_mode_probed_add(connector, newmode);
6742 static int add_displayid_detailed_modes(struct drm_connector *connector,
6753 num_modes += add_displayid_detailed_1_modes(connector, block);
6760 static int _drm_edid_connector_add_modes(struct drm_connector *connector,
6763 const struct drm_display_info *info = &connector->display_info;
6783 num_modes += add_detailed_modes(connector, drm_edid);
6784 num_modes += add_cvt_modes(connector, drm_edid);
6785 num_modes += add_standard_modes(connector, drm_edid);
6786 num_modes += add_established_modes(connector, drm_edid);
6787 num_modes += add_cea_modes(connector, drm_edid);
6788 num_modes += add_alternate_cea_modes(connector, drm_edid);
6789 num_modes += add_displayid_detailed_modes(connector, drm_edid);
6791 num_modes += add_inferred_modes(connector, drm_edid);
6794 edid_fixup_preferred(connector);
6799 static void _drm_update_tile_info(struct drm_connector *connector,
6802 static int _drm_edid_connector_property_update(struct drm_connector *connector,
6805 struct drm_device *dev = connector->dev;
6808 if (connector->edid_blob_ptr) {
6809 const struct edid *old_edid = connector->edid_blob_ptr->data;
6813 connector->epoch_counter++;
6815 connector->base.id, connector->name,
6816 connector->epoch_counter);
6822 &connector->edid_blob_ptr,
6825 &connector->base,
6829 connector->base.id, connector->name, ret);
6833 ret = drm_object_property_set_value(&connector->base,
6835 connector->display_info.non_desktop);
6838 connector->base.id, connector->name, ret);
6842 ret = drm_connector_set_tile_property(connector);
6845 connector->base.id, connector->name, ret);
6854 * drm_edid_connector_update - Update connector information from EDID
6855 * @connector: Connector
6858 * Update the connector display info, ELD, HDR metadata, relevant properties,
6867 int drm_edid_connector_update(struct drm_connector *connector,
6870 update_display_info(connector, drm_edid);
6872 _drm_update_tile_info(connector, drm_edid);
6874 return _drm_edid_connector_property_update(connector, drm_edid);
6880 * @connector: Connector
6882 * Add the modes from the previously updated EDID property to the connector
6890 int drm_edid_connector_add_modes(struct drm_connector *connector)
6895 if (connector->edid_blob_ptr)
6896 drm_edid = drm_edid_alloc(connector->edid_blob_ptr->data,
6897 connector->edid_blob_ptr->length);
6899 count = _drm_edid_connector_add_modes(connector, drm_edid);
6908 * drm_connector_update_edid_property - update the edid property of a connector
6909 * @connector: drm connector
6913 * connector's edid property.
6915 * set the connector's tile property here. See drm_connector_set_tile_property()
6923 int drm_connector_update_edid_property(struct drm_connector *connector,
6928 return drm_edid_connector_update(connector, drm_edid_legacy_init(&drm_edid, edid));
6934 * @connector: connector we're probing
6937 * Add the specified modes to the connector's mode list. Also fills out the
6938 * &drm_display_info structure and ELD in @connector with any information which
6945 int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
6951 drm_warn(connector->dev, "[CONNECTOR:%d:%s] EDID invalid.\n",
6952 connector->base.id, connector->name);
6958 update_display_info(connector, drm_edid);
6960 return _drm_edid_connector_add_modes(connector, drm_edid);
6966 * @connector: connector we're probing
6970 * Add the specified modes to the connector's mode list. Only when the
6975 int drm_add_modes_noedid(struct drm_connector *connector,
6980 struct drm_device *dev = connector->dev;
6995 * the connector.
7005 drm_mode_probed_add(connector, mode);
7014 * drm_set_preferred_mode - Sets the preferred mode of a connector
7015 * @connector: connector whose mode list should be processed
7022 void drm_set_preferred_mode(struct drm_connector *connector,
7027 list_for_each_entry(mode, &connector->probed_modes, head) {
7035 static bool is_hdmi2_sink(const struct drm_connector *connector)
7038 * FIXME: sil-sii8620 doesn't have a connector around when
7039 * we need one, so we have to be prepared for a NULL connector.
7041 if (!connector)
7044 return connector->display_info.hdmi.scdc.supported ||
7045 connector->display_info.color_formats & DRM_COLOR_FORMAT_YCBCR420;
7048 static u8 drm_mode_hdmi_vic(const struct drm_connector *connector,
7051 bool has_hdmi_infoframe = connector ?
7052 connector->display_info.has_hdmi_infoframe : false;
7064 static u8 drm_mode_cea_vic(const struct drm_connector *connector,
7073 if (drm_mode_hdmi_vic(connector, mode))
7089 static u8 vic_for_avi_infoframe(const struct drm_connector *connector, u8 vic)
7091 if (!is_hdmi2_sink(connector) && vic > 64 &&
7092 !cta_vdb_has_vic(connector, vic))
7102 * @connector: the connector
7109 const struct drm_connector *connector,
7123 vic = drm_mode_cea_vic(connector, mode);
7124 hdmi_vic = drm_mode_hdmi_vic(connector, mode);
7129 * As some drivers don't support atomic, we can't use connector state.
7167 frame->video_code = vic_for_avi_infoframe(connector, vic);
7180 * @connector: the connector
7186 const struct drm_connector *connector,
7190 const struct drm_display_info *info = &connector->display_info;
7221 if (!is_hdmi2_sink(connector) ||
7262 * @connector: the connector
7273 const struct drm_connector *connector,
7277 * FIXME: sil-sii8620 doesn't have a connector around when
7278 * we need one, so we have to be prepared for a NULL connector.
7280 bool has_hdmi_infoframe = connector ?
7281 connector->display_info.has_hdmi_infoframe : false;
7303 frame->vic = drm_mode_hdmi_vic(connector, mode);
7310 static void drm_parse_tiled_block(struct drm_connector *connector,
7327 connector->has_tile = true;
7329 connector->tile_is_single_monitor = true;
7331 connector->num_h_tile = num_h_tile + 1;
7332 connector->num_v_tile = num_v_tile + 1;
7333 connector->tile_h_loc = tile_h_loc;
7334 connector->tile_v_loc = tile_v_loc;
7335 connector->tile_h_size = w + 1;
7336 connector->tile_v_size = h + 1;
7338 drm_dbg_kms(connector->dev,
7340 connector->base.id, connector->name,
7342 connector->tile_h_size, connector->tile_v_size,
7343 connector->num_h_tile, connector->num_v_tile,
7344 connector->tile_h_loc, connector->tile_v_loc,
7347 tg = drm_mode_get_tile_group(connector->dev, tile->topology_id);
7349 tg = drm_mode_create_tile_group(connector->dev, tile->topology_id);
7353 if (connector->tile_group != tg) {
7356 if (connector->tile_group)
7357 drm_mode_put_tile_group(connector->dev, connector->tile_group);
7358 connector->tile_group = tg;
7361 drm_mode_put_tile_group(connector->dev, tg);
7374 static void _drm_update_tile_info(struct drm_connector *connector,
7380 connector->has_tile = false;
7385 drm_parse_tiled_block(connector, block);
7389 if (!connector->has_tile && connector->tile_group) {
7390 drm_mode_put_tile_group(connector->dev, connector->tile_group);
7391 connector->tile_group = NULL;