Lines Matching defs:connector
96 struct drm_connector *connector;
2188 static void connector_bad_edid(struct drm_connector *connector,
2204 connector->real_edid_checksum =
2207 if (connector->bad_edid_counter++ && !drm_debug_enabled(DRM_UT_KMS))
2210 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID is invalid:\n",
2211 connector->base.id, connector->name);
2217 static const struct drm_edid *drm_edid_override_get(struct drm_connector *connector)
2221 mutex_lock(&connector->edid_override_mutex);
2223 if (connector->edid_override)
2224 override = drm_edid_dup(connector->edid_override);
2226 mutex_unlock(&connector->edid_override_mutex);
2229 override = drm_edid_load_firmware(connector);
2235 int drm_edid_override_show(struct drm_connector *connector, struct seq_file *m)
2239 mutex_lock(&connector->edid_override_mutex);
2241 drm_edid = connector->edid_override;
2245 mutex_unlock(&connector->edid_override_mutex);
2251 int drm_edid_override_set(struct drm_connector *connector, const void *edid,
2258 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID override invalid\n",
2259 connector->base.id, connector->name);
2264 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID override set\n",
2265 connector->base.id, connector->name);
2267 mutex_lock(&connector->edid_override_mutex);
2269 drm_edid_free(connector->edid_override);
2270 connector->edid_override = drm_edid;
2272 mutex_unlock(&connector->edid_override_mutex);
2278 int drm_edid_override_reset(struct drm_connector *connector)
2280 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] EDID override reset\n",
2281 connector->base.id, connector->name);
2283 mutex_lock(&connector->edid_override_mutex);
2285 drm_edid_free(connector->edid_override);
2286 connector->edid_override = NULL;
2288 mutex_unlock(&connector->edid_override_mutex);
2295 * @connector: connector we're probing
2304 int drm_edid_override_connector_update(struct drm_connector *connector)
2309 override = drm_edid_override_get(connector);
2311 if (drm_edid_connector_update(connector, override) == 0)
2312 num_modes = drm_edid_connector_add_modes(connector);
2316 drm_dbg_kms(connector->dev,
2318 connector->base.id, connector->name, num_modes);
2360 static struct edid *_drm_do_get_edid(struct drm_connector *connector,
2370 override = drm_edid_override_get(connector);
2393 connector->edid_corrupt = false;
2395 connector->edid_corrupt = true;
2399 connector->null_edid_counter++;
2401 connector_bad_edid(connector, edid, 1);
2450 connector_bad_edid(connector, edid, num_blocks);
2468 * @connector: connector we're probing
2486 struct edid *drm_do_get_edid(struct drm_connector *connector,
2490 return _drm_do_get_edid(connector, read_block, context, NULL);
2618 * @connector: connector we're probing
2622 * attach it to the connector.
2626 struct edid *drm_get_edid(struct drm_connector *connector,
2631 if (connector->force == DRM_FORCE_OFF)
2634 if (connector->force == DRM_FORCE_UNSPECIFIED && !drm_probe_ddc(adapter))
2637 edid = _drm_do_get_edid(connector, drm_do_probe_ddc_edid, adapter, NULL);
2638 drm_connector_update_edid_property(connector, edid);
2645 * @connector: Connector to use
2666 const struct drm_edid *drm_edid_read_custom(struct drm_connector *connector,
2674 edid = _drm_do_get_edid(connector, read_block, context, &size);
2679 drm_WARN_ON(connector->dev, !size);
2691 * @connector: Connector to use
2700 * Prefer initializing connector->ddc with drm_connector_init_with_ddc() and
2707 const struct drm_edid *drm_edid_read_ddc(struct drm_connector *connector,
2712 if (connector->force == DRM_FORCE_OFF)
2715 if (connector->force == DRM_FORCE_UNSPECIFIED && !drm_probe_ddc(adapter))
2718 drm_edid = drm_edid_read_custom(connector, drm_do_probe_ddc_edid, adapter);
2720 /* Note: Do *not* call connector updates here. */
2727 * drm_edid_read - Read EDID data using connector's I2C adapter
2728 * @connector: Connector to use
2730 * Read EDID using the connector's I2C adapter.
2740 const struct drm_edid *drm_edid_read(struct drm_connector *connector)
2742 if (drm_WARN_ON(connector->dev, !connector->ddc))
2745 return drm_edid_read_ddc(connector, connector->ddc);
2825 * @connector: connector we're probing
2834 struct edid *drm_get_edid_switcheroo(struct drm_connector *connector,
2837 struct drm_device *dev = connector->dev;
2845 edid = drm_get_edid(connector, adapter);
2854 * @connector: connector we're probing
2863 const struct drm_edid *drm_edid_read_switcheroo(struct drm_connector *connector,
2866 struct drm_device *dev = connector->dev;
2874 drm_edid = drm_edid_read_ddc(connector, adapter);
2923 * Walk the mode list for connector, clearing the preferred status on existing
2926 static void edid_fixup_preferred(struct drm_connector *connector)
2928 const struct drm_display_info *info = &connector->display_info;
2933 if (list_empty(&connector->probed_modes))
2941 preferred_mode = list_first_entry(&connector->probed_modes,
2944 list_for_each_entry_safe(cur_mode, t, &connector->probed_modes, head) {
3297 static struct drm_display_mode *drm_mode_std(struct drm_connector *connector,
3301 struct drm_device *dev = connector->dev;
3340 * If this connector already has a mode for this size and refresh
3345 list_for_each_entry(m, &connector->probed_modes, head)
3438 static struct drm_display_mode *drm_mode_detailed(struct drm_connector *connector,
3442 const struct drm_display_info *info = &connector->display_info;
3443 struct drm_device *dev = connector->dev;
3461 connector->base.id, connector->name);
3466 connector->base.id, connector->name);
3472 connector->base.id, connector->name);
3506 connector->base.id, connector->name,
3512 connector->base.id, connector->name,
3626 static bool valid_inferred_mode(const struct drm_connector *connector,
3632 list_for_each_entry(m, &connector->probed_modes, head) {
3644 static int drm_dmt_modes_for_range(struct drm_connector *connector,
3650 struct drm_device *dev = connector->dev;
3654 valid_inferred_mode(connector, drm_dmt_modes + i)) {
3657 drm_mode_probed_add(connector, newmode);
3679 static int drm_gtf_modes_for_range(struct drm_connector *connector,
3685 struct drm_device *dev = connector->dev;
3696 !valid_inferred_mode(connector, newmode)) {
3701 drm_mode_probed_add(connector, newmode);
3708 static int drm_gtf2_modes_for_range(struct drm_connector *connector,
3714 struct drm_device *dev = connector->dev;
3725 !valid_inferred_mode(connector, newmode)) {
3730 drm_mode_probed_add(connector, newmode);
3737 static int drm_cvt_modes_for_range(struct drm_connector *connector,
3743 struct drm_device *dev = connector->dev;
3755 !valid_inferred_mode(connector, newmode)) {
3760 drm_mode_probed_add(connector, newmode);
3777 closure->modes += drm_dmt_modes_for_range(closure->connector,
3786 closure->modes += drm_gtf2_modes_for_range(closure->connector,
3791 closure->modes += drm_gtf_modes_for_range(closure->connector,
3799 closure->modes += drm_cvt_modes_for_range(closure->connector,
3809 static int add_inferred_modes(struct drm_connector *connector,
3813 .connector = connector,
3824 drm_est3_modes(struct drm_connector *connector, const struct detailed_timing *timing)
3836 mode = drm_mode_find_dmt(connector->dev,
3842 drm_mode_probed_add(connector, mode);
3860 closure->modes += drm_est3_modes(closure->connector, timing);
3868 static int add_established_modes(struct drm_connector *connector,
3871 struct drm_device *dev = connector->dev;
3878 .connector = connector,
3888 drm_mode_probed_add(connector, newmode);
3906 struct drm_connector *connector = closure->connector;
3916 newmode = drm_mode_std(connector, closure->drm_edid, std);
3918 drm_mode_probed_add(connector, newmode);
3929 static int add_standard_modes(struct drm_connector *connector,
3934 .connector = connector,
3941 newmode = drm_mode_std(connector, drm_edid,
3944 drm_mode_probed_add(connector, newmode);
3958 static int drm_cvt_modes(struct drm_connector *connector,
3963 struct drm_device *dev = connector->dev;
4000 drm_mode_probed_add(connector, newmode);
4018 closure->modes += drm_cvt_modes(closure->connector, timing);
4022 add_cvt_modes(struct drm_connector *connector, const struct drm_edid *drm_edid)
4025 .connector = connector,
4037 static void fixup_detailed_cea_mode_clock(struct drm_connector *connector,
4049 newmode = drm_mode_detailed(closure->connector,
4062 fixup_detailed_cea_mode_clock(closure->connector, newmode);
4064 drm_mode_probed_add(closure->connector, newmode);
4071 * @connector: attached connector
4074 static int add_detailed_modes(struct drm_connector *connector,
4078 .connector = connector,
4431 static int add_alternate_cea_modes(struct drm_connector *connector,
4434 struct drm_device *dev = connector->dev;
4447 list_for_each_entry(mode, &connector->probed_modes, head) {
4496 drm_mode_probed_add(connector, mode);
4517 drm_display_mode_from_vic_index(struct drm_connector *connector, int vic_index)
4519 const struct drm_display_info *info = &connector->display_info;
4520 struct drm_device *dev = connector->dev;
4530 * @connector: connector corresponding to the HDMI sink
4538 static int do_y420vdb_modes(struct drm_connector *connector,
4541 struct drm_device *dev = connector->dev;
4554 drm_mode_probed_add(connector, newmode);
4590 static int add_cta_vdb_modes(struct drm_connector *connector)
4592 const struct drm_display_info *info = &connector->display_info;
4601 mode = drm_display_mode_from_vic_index(connector, i);
4603 drm_mode_probed_add(connector, mode);
4641 static int add_hdmi_mandatory_stereo_modes(struct drm_connector *connector)
4643 struct drm_device *dev = connector->dev;
4650 list_for_each_entry(mode, &connector->probed_modes, head) {
4670 list_splice_tail(&stereo_modes, &connector->probed_modes);
4675 static int add_hdmi_mode(struct drm_connector *connector, u8 vic)
4677 struct drm_device *dev = connector->dev;
4681 drm_err(connector->dev, "[CONNECTOR:%d:%s] Unknown HDMI VIC: %d\n",
4682 connector->base.id, connector->name, vic);
4690 drm_mode_probed_add(connector, newmode);
4695 static int add_3d_struct_modes(struct drm_connector *connector, u16 structure,
4702 newmode = drm_display_mode_from_vic_index(connector, vic_index);
4705 drm_mode_probed_add(connector, newmode);
4710 newmode = drm_display_mode_from_vic_index(connector, vic_index);
4713 drm_mode_probed_add(connector, newmode);
4718 newmode = drm_display_mode_from_vic_index(connector, vic_index);
4721 drm_mode_probed_add(connector, newmode);
4751 * @connector: connector corresponding to the HDMI sink
4755 * Parses the HDMI VSDB looking for modes to add to @connector. This function
4759 do_hdmi_vsdb_modes(struct drm_connector *connector, const u8 *db, u8 len)
4783 modes += add_hdmi_mandatory_stereo_modes(connector);
4797 modes += add_hdmi_mode(connector, vic);
4826 modes += add_3d_struct_modes(connector,
4863 newmode = drm_display_mode_from_vic_index(connector,
4868 drm_mode_probed_add(connector, newmode);
5215 static void parse_cta_y420cmdb(struct drm_connector *connector,
5218 struct drm_display_info *info = &connector->display_info;
5254 static int add_cea_modes(struct drm_connector *connector,
5262 modes = add_cta_vdb_modes(connector);
5267 modes += do_hdmi_vsdb_modes(connector, (const u8 *)db,
5273 modes += do_y420vdb_modes(connector, vdb420,
5282 static void fixup_detailed_cea_mode_clock(struct drm_connector *connector,
5321 drm_dbg_kms(connector->dev,
5323 connector->base.id, connector->name,
5328 static void drm_calculate_luminance_range(struct drm_connector *connector)
5330 struct hdr_static_metadata *hdr_metadata = &connector->hdr_sink_metadata.hdmi_type1;
5332 &connector->display_info.luminance_range;
5389 drm_parse_hdr_metadata_block(struct drm_connector *connector, const u8 *db)
5395 connector->hdr_sink_metadata.hdmi_type1.eotf =
5397 connector->hdr_sink_metadata.hdmi_type1.metadata_type =
5401 connector->hdr_sink_metadata.hdmi_type1.max_cll = db[4];
5403 connector->hdr_sink_metadata.hdmi_type1.max_fall = db[5];
5405 connector->hdr_sink_metadata.hdmi_type1.min_cll = db[6];
5408 drm_calculate_luminance_range(connector);
5414 drm_parse_hdmi_vsdb_audio(struct drm_connector *connector, const u8 *db)
5419 connector->eld[DRM_ELD_SAD_COUNT_CONN_TYPE] |= DRM_ELD_SUPPORTS_AI;
5422 connector->latency_present[0] = true;
5423 connector->video_latency[0] = db[9];
5424 connector->audio_latency[0] = db[10];
5428 connector->latency_present[1] = true;
5429 connector->video_latency[1] = db[11];
5430 connector->audio_latency[1] = db[12];
5433 drm_dbg_kms(connector->dev,
5435 connector->base.id, connector->name,
5436 connector->latency_present[0], connector->latency_present[1],
5437 connector->video_latency[0], connector->video_latency[1],
5438 connector->audio_latency[0], connector->audio_latency[1]);
5500 static void clear_eld(struct drm_connector *connector)
5502 memset(connector->eld, 0, sizeof(connector->eld));
5504 connector->latency_present[0] = false;
5505 connector->latency_present[1] = false;
5506 connector->video_latency[0] = 0;
5507 connector->audio_latency[0] = 0;
5508 connector->video_latency[1] = 0;
5509 connector->audio_latency[1] = 0;
5514 * @connector: connector corresponding to the HDMI/DP sink
5520 static void drm_edid_to_eld(struct drm_connector *connector,
5523 const struct drm_display_info *info = &connector->display_info;
5526 uint8_t *eld = connector->eld;
5534 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] ELD monitor %s\n",
5535 connector->base.id, connector->name,
5571 drm_parse_hdmi_vsdb_audio(connector, (const u8 *)db);
5581 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
5582 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
5590 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] ELD size %d, SAD count %d\n",
5591 connector->base.id, connector->name,
5697 * @connector: connector associated with the HDMI/DP sink
5703 int drm_av_sync_delay(struct drm_connector *connector,
5709 if (!connector->latency_present[0])
5711 if (!connector->latency_present[1])
5714 a = connector->audio_latency[i];
5715 v = connector->video_latency[i];
5860 static void parse_cta_vdb(struct drm_connector *connector, const struct cea_db *db)
5862 struct drm_display_info *info = &connector->display_info;
5895 static void update_cta_y420cmdb(struct drm_connector *connector, u64 y420cmdb_map)
5897 struct drm_display_info *info = &connector->display_info;
5909 static bool cta_vdb_has_vic(const struct drm_connector *connector, u8 vic)
5911 const struct drm_display_info *info = &connector->display_info;
5926 static void parse_cta_y420vdb(struct drm_connector *connector,
5929 struct drm_display_info *info = &connector->display_info;
5945 static void drm_parse_vcdb(struct drm_connector *connector, const u8 *db)
5947 struct drm_display_info *info = &connector->display_info;
5949 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] CEA VCDB 0x%02x\n",
5950 connector->base.id, connector->name, db[2]);
5991 static void drm_parse_ycbcr420_deep_color_info(struct drm_connector *connector,
5995 struct drm_hdmi_info *hdmi = &connector->display_info.hdmi;
6073 static void drm_parse_hdmi_forum_scds(struct drm_connector *connector,
6076 struct drm_display_info *info = &connector->display_info;
6125 drm_parse_ycbcr420_deep_color_info(connector, hf_scds);
6132 drm_dbg_kms(connector->dev,
6134 connector->base.id, connector->name,
6138 static void drm_parse_hdmi_deep_color_info(struct drm_connector *connector,
6141 struct drm_display_info *info = &connector->display_info;
6153 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does deep color 30.\n",
6154 connector->base.id, connector->name);
6160 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does deep color 36.\n",
6161 connector->base.id, connector->name);
6167 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does deep color 48.\n",
6168 connector->base.id, connector->name);
6172 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] No deep color support on this HDMI sink.\n",
6173 connector->base.id, connector->name);
6177 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] Assigning HDMI sink color depth as %d bpc.\n",
6178 connector->base.id, connector->name, dc_bpc);
6184 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink does YCRCB444 in deep color.\n",
6185 connector->base.id, connector->name);
6193 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI sink should do DC_36, but does not!\n",
6194 connector->base.id, connector->name);
6200 drm_parse_hdmi_vsdb_video(struct drm_connector *connector, const u8 *db)
6202 struct drm_display_info *info = &connector->display_info;
6221 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] HDMI: DVI dual %d, max TMDS clock %d kHz\n",
6222 connector->base.id, connector->name,
6225 drm_parse_hdmi_deep_color_info(connector, db);
6232 static void drm_parse_microsoft_vsdb(struct drm_connector *connector,
6235 struct drm_display_info *info = &connector->display_info;
6243 drm_dbg_kms(connector->dev,
6245 connector->base.id, connector->name, version, db[5]);
6248 static void drm_parse_cea_ext(struct drm_connector *connector,
6251 struct drm_display_info *info = &connector->display_info;
6267 drm_dbg_kms(connector->dev,
6269 connector->base.id, connector->name,
6290 drm_parse_hdmi_vsdb_video(connector, data);
6293 drm_parse_hdmi_forum_scds(connector, data);
6295 drm_parse_microsoft_vsdb(connector, data);
6297 parse_cta_y420cmdb(connector, db, &y420cmdb_map);
6299 parse_cta_y420vdb(connector, db);
6301 drm_parse_vcdb(connector, data);
6303 drm_parse_hdr_metadata_block(connector, data);
6305 parse_cta_vdb(connector, db);
6312 update_cta_y420cmdb(connector, y420cmdb_map);
6319 struct drm_display_info *info = &closure->connector->display_info;
6351 static void drm_get_monitor_range(struct drm_connector *connector,
6354 const struct drm_display_info *info = &connector->display_info;
6356 .connector = connector,
6368 drm_dbg_kms(connector->dev,
6370 connector->base.id, connector->name,
6374 static void drm_parse_vesa_mso_data(struct drm_connector *connector,
6379 struct drm_display_info *info = &connector->display_info;
6382 drm_dbg_kms(connector->dev,
6384 connector->base.id, connector->name, block->num_bytes);
6392 drm_dbg_kms(connector->dev,
6394 connector->base.id, connector->name);
6400 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] Reserved MSO mode value\n",
6401 connector->base.id, connector->name);
6421 drm_dbg_kms(connector->dev,
6423 connector->base.id, connector->name,
6428 drm_dbg_kms(connector->dev,
6430 connector->base.id, connector->name,
6434 static void drm_update_mso(struct drm_connector *connector,
6443 drm_parse_vesa_mso_data(connector, block);
6448 /* A connector has no EDID information, so we've got no EDID to compute quirks from. Reset
6451 static void drm_reset_display_info(struct drm_connector *connector)
6453 struct drm_display_info *info = &connector->display_info;
6487 static void update_displayid_info(struct drm_connector *connector,
6490 struct drm_display_info *info = &connector->display_info;
6510 static void update_display_info(struct drm_connector *connector,
6513 struct drm_display_info *info = &connector->display_info;
6516 drm_reset_display_info(connector);
6517 clear_eld(connector);
6529 drm_get_monitor_range(connector, drm_edid);
6538 drm_parse_cea_ext(connector, drm_edid);
6540 update_displayid_info(connector, drm_edid);
6552 drm_dbg_kms(connector->dev,
6554 connector->base.id, connector->name, info->bpc);
6586 drm_dbg_kms(connector->dev,
6588 connector->base.id, connector->name, info->bpc);
6595 drm_update_mso(connector, drm_edid);
6599 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s] Non-desktop display%s\n",
6600 connector->base.id, connector->name,
6621 drm_edid_to_eld(connector, drm_edid);
6671 static int add_displayid_detailed_1_modes(struct drm_connector *connector,
6688 newmode = drm_mode_displayid_detailed(connector->dev, timings, type_7);
6692 drm_mode_probed_add(connector, newmode);
6698 static int add_displayid_detailed_modes(struct drm_connector *connector,
6709 num_modes += add_displayid_detailed_1_modes(connector, block);
6716 static int _drm_edid_connector_add_modes(struct drm_connector *connector,
6719 const struct drm_display_info *info = &connector->display_info;
6739 num_modes += add_detailed_modes(connector, drm_edid);
6740 num_modes += add_cvt_modes(connector, drm_edid);
6741 num_modes += add_standard_modes(connector, drm_edid);
6742 num_modes += add_established_modes(connector, drm_edid);
6743 num_modes += add_cea_modes(connector, drm_edid);
6744 num_modes += add_alternate_cea_modes(connector, drm_edid);
6745 num_modes += add_displayid_detailed_modes(connector, drm_edid);
6747 num_modes += add_inferred_modes(connector, drm_edid);
6750 edid_fixup_preferred(connector);
6755 static void _drm_update_tile_info(struct drm_connector *connector,
6758 static int _drm_edid_connector_property_update(struct drm_connector *connector,
6761 struct drm_device *dev = connector->dev;
6764 if (connector->edid_blob_ptr) {
6765 const struct edid *old_edid = connector->edid_blob_ptr->data;
6769 connector->epoch_counter++;
6771 connector->base.id, connector->name,
6772 connector->epoch_counter);
6778 &connector->edid_blob_ptr,
6781 &connector->base,
6785 connector->base.id, connector->name, ret);
6789 ret = drm_object_property_set_value(&connector->base,
6791 connector->display_info.non_desktop);
6794 connector->base.id, connector->name, ret);
6798 ret = drm_connector_set_tile_property(connector);
6801 connector->base.id, connector->name, ret);
6810 * drm_edid_connector_update - Update connector information from EDID
6811 * @connector: Connector
6814 * Update the connector display info, ELD, HDR metadata, relevant properties,
6823 int drm_edid_connector_update(struct drm_connector *connector,
6826 update_display_info(connector, drm_edid);
6828 _drm_update_tile_info(connector, drm_edid);
6830 return _drm_edid_connector_property_update(connector, drm_edid);
6836 * @connector: Connector
6838 * Add the modes from the previously updated EDID property to the connector
6846 int drm_edid_connector_add_modes(struct drm_connector *connector)
6851 if (connector->edid_blob_ptr)
6852 drm_edid = drm_edid_alloc(connector->edid_blob_ptr->data,
6853 connector->edid_blob_ptr->length);
6855 count = _drm_edid_connector_add_modes(connector, drm_edid);
6864 * drm_connector_update_edid_property - update the edid property of a connector
6865 * @connector: drm connector
6869 * connector's edid property.
6871 * set the connector's tile property here. See drm_connector_set_tile_property()
6879 int drm_connector_update_edid_property(struct drm_connector *connector,
6884 return drm_edid_connector_update(connector, drm_edid_legacy_init(&drm_edid, edid));
6890 * @connector: connector we're probing
6893 * Add the specified modes to the connector's mode list. Also fills out the
6894 * &drm_display_info structure and ELD in @connector with any information which
6901 int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
6907 drm_warn(connector->dev, "[CONNECTOR:%d:%s] EDID invalid.\n",
6908 connector->base.id, connector->name);
6914 update_display_info(connector, drm_edid);
6916 return _drm_edid_connector_add_modes(connector, drm_edid);
6922 * @connector: connector we're probing
6926 * Add the specified modes to the connector's mode list. Only when the
6931 int drm_add_modes_noedid(struct drm_connector *connector,
6936 struct drm_device *dev = connector->dev;
6951 * the connector.
6961 drm_mode_probed_add(connector, mode);
6970 * drm_set_preferred_mode - Sets the preferred mode of a connector
6971 * @connector: connector whose mode list should be processed
6978 void drm_set_preferred_mode(struct drm_connector *connector,
6983 list_for_each_entry(mode, &connector->probed_modes, head) {
6991 static bool is_hdmi2_sink(const struct drm_connector *connector)
6994 * FIXME: sil-sii8620 doesn't have a connector around when
6995 * we need one, so we have to be prepared for a NULL connector.
6997 if (!connector)
7000 return connector->display_info.hdmi.scdc.supported ||
7001 connector->display_info.color_formats & DRM_COLOR_FORMAT_YCBCR420;
7004 static u8 drm_mode_hdmi_vic(const struct drm_connector *connector,
7007 bool has_hdmi_infoframe = connector ?
7008 connector->display_info.has_hdmi_infoframe : false;
7020 static u8 drm_mode_cea_vic(const struct drm_connector *connector,
7029 if (drm_mode_hdmi_vic(connector, mode))
7045 static u8 vic_for_avi_infoframe(const struct drm_connector *connector, u8 vic)
7047 if (!is_hdmi2_sink(connector) && vic > 64 &&
7048 !cta_vdb_has_vic(connector, vic))
7058 * @connector: the connector
7065 const struct drm_connector *connector,
7079 vic = drm_mode_cea_vic(connector, mode);
7080 hdmi_vic = drm_mode_hdmi_vic(connector, mode);
7085 * As some drivers don't support atomic, we can't use connector state.
7123 frame->video_code = vic_for_avi_infoframe(connector, vic);
7136 * @connector: the connector
7142 const struct drm_connector *connector,
7146 const struct drm_display_info *info = &connector->display_info;
7177 if (!is_hdmi2_sink(connector) ||
7218 * @connector: the connector
7229 const struct drm_connector *connector,
7233 * FIXME: sil-sii8620 doesn't have a connector around when
7234 * we need one, so we have to be prepared for a NULL connector.
7236 bool has_hdmi_infoframe = connector ?
7237 connector->display_info.has_hdmi_infoframe : false;
7259 frame->vic = drm_mode_hdmi_vic(connector, mode);
7266 static void drm_parse_tiled_block(struct drm_connector *connector,
7283 connector->has_tile = true;
7285 connector->tile_is_single_monitor = true;
7287 connector->num_h_tile = num_h_tile + 1;
7288 connector->num_v_tile = num_v_tile + 1;
7289 connector->tile_h_loc = tile_h_loc;
7290 connector->tile_v_loc = tile_v_loc;
7291 connector->tile_h_size = w + 1;
7292 connector->tile_v_size = h + 1;
7294 drm_dbg_kms(connector->dev,
7296 connector->base.id, connector->name,
7298 connector->tile_h_size, connector->tile_v_size,
7299 connector->num_h_tile, connector->num_v_tile,
7300 connector->tile_h_loc, connector->tile_v_loc,
7303 tg = drm_mode_get_tile_group(connector->dev, tile->topology_id);
7305 tg = drm_mode_create_tile_group(connector->dev, tile->topology_id);
7309 if (connector->tile_group != tg) {
7312 if (connector->tile_group)
7313 drm_mode_put_tile_group(connector->dev, connector->tile_group);
7314 connector->tile_group = tg;
7317 drm_mode_put_tile_group(connector->dev, tg);
7330 static void _drm_update_tile_info(struct drm_connector *connector,
7336 connector->has_tile = false;
7341 drm_parse_tiled_block(connector, block);
7345 if (!connector->has_tile && connector->tile_group) {
7346 drm_mode_put_tile_group(connector->dev, connector->tile_group);
7347 connector->tile_group = NULL;