2 * Copyright 2007-8 Advanced Micro Devices, Inc.
3 * Copyright 2008 Red Hat Inc.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
23 * Authors: Dave Airlie
27 #include <drm/drm_edid.h>
28 #include <drm/drm_crtc_helper.h>
29 #include <drm/drm_fb_helper.h>
30 #include <drm/drm_dp_mst_helper.h>
31 #include <drm/radeon_drm.h>
33 #include "radeon_audio.h"
36 #include <linux/pm_runtime.h>
37 #include <linux/vga_switcheroo.h>
39 static int radeon_dp_handle_hpd(struct drm_connector *connector)
41 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
44 ret = radeon_dp_mst_check_status(radeon_connector);
49 void radeon_connector_hotplug(struct drm_connector *connector)
51 struct drm_device *dev = connector->dev;
52 struct radeon_device *rdev = dev->dev_private;
53 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
55 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
56 struct radeon_connector_atom_dig *dig_connector =
57 radeon_connector->con_priv;
59 if (radeon_connector->is_mst_connector)
61 if (dig_connector->is_mst) {
62 radeon_dp_handle_hpd(connector);
66 /* bail if the connector does not have hpd pin, e.g.,
69 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
72 radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
74 /* if the connector is already off, don't turn it back on */
75 /* FIXME: This access isn't protected by any locks. */
76 if (connector->dpms != DRM_MODE_DPMS_ON)
79 /* just deal with DP (not eDP) here. */
80 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
81 struct radeon_connector_atom_dig *dig_connector =
82 radeon_connector->con_priv;
84 /* if existing sink type was not DP no need to retrain */
85 if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
88 /* first get sink type as it may be reset after (un)plug */
89 dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
90 /* don't do anything if sink is not display port, i.e.,
91 * passive dp->(dvi|hdmi) adaptor
93 if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT &&
94 radeon_hpd_sense(rdev, radeon_connector->hpd.hpd) &&
95 radeon_dp_needs_link_train(radeon_connector)) {
96 /* Don't start link training before we have the DPCD */
97 if (!radeon_dp_getdpcd(radeon_connector))
100 /* Turn the connector off and back on immediately, which
101 * will trigger link training
103 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
104 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
109 static void radeon_property_change_mode(struct drm_encoder *encoder)
111 struct drm_crtc *crtc = encoder->crtc;
113 if (crtc && crtc->enabled) {
114 drm_crtc_helper_set_mode(crtc, &crtc->mode,
115 crtc->x, crtc->y, crtc->primary->fb);
119 int radeon_get_monitor_bpc(struct drm_connector *connector)
121 struct drm_device *dev = connector->dev;
122 struct radeon_device *rdev = dev->dev_private;
123 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
124 struct radeon_connector_atom_dig *dig_connector;
126 int mode_clock, max_tmds_clock;
128 switch (connector->connector_type) {
129 case DRM_MODE_CONNECTOR_DVII:
130 case DRM_MODE_CONNECTOR_HDMIB:
131 if (radeon_connector->use_digital) {
132 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
133 if (connector->display_info.bpc)
134 bpc = connector->display_info.bpc;
138 case DRM_MODE_CONNECTOR_DVID:
139 case DRM_MODE_CONNECTOR_HDMIA:
140 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
141 if (connector->display_info.bpc)
142 bpc = connector->display_info.bpc;
145 case DRM_MODE_CONNECTOR_DisplayPort:
146 dig_connector = radeon_connector->con_priv;
147 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
148 (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
149 drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
150 if (connector->display_info.bpc)
151 bpc = connector->display_info.bpc;
154 case DRM_MODE_CONNECTOR_eDP:
155 case DRM_MODE_CONNECTOR_LVDS:
156 if (connector->display_info.bpc)
157 bpc = connector->display_info.bpc;
158 else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
159 const struct drm_connector_helper_funcs *connector_funcs =
160 connector->helper_private;
161 struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
162 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
163 struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
165 if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
167 else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
173 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
174 /* hdmi deep color only implemented on DCE4+ */
175 if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
176 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
177 connector->name, bpc);
182 * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
183 * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
184 * 12 bpc is always supported on hdmi deep color sinks, as this is
185 * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
188 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
189 connector->name, bpc);
193 /* Any defined maximum tmds clock limit we must not exceed? */
194 if (connector->display_info.max_tmds_clock > 0) {
195 /* mode_clock is clock in kHz for mode to be modeset on this connector */
196 mode_clock = radeon_connector->pixelclock_for_modeset;
198 /* Maximum allowable input clock in kHz */
199 max_tmds_clock = connector->display_info.max_tmds_clock;
201 DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
202 connector->name, mode_clock, max_tmds_clock);
204 /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
205 if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
206 if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
207 (mode_clock * 5/4 <= max_tmds_clock))
212 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
213 connector->name, bpc);
216 if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
218 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
219 connector->name, bpc);
223 /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
224 DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
230 if ((radeon_deep_color == 0) && (bpc > 8)) {
231 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
236 DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
237 connector->name, connector->display_info.bpc, bpc);
243 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
245 struct drm_device *dev = connector->dev;
246 struct radeon_device *rdev = dev->dev_private;
247 struct drm_encoder *best_encoder = NULL;
248 struct drm_encoder *encoder = NULL;
249 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
253 best_encoder = connector_funcs->best_encoder(connector);
255 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
256 if (connector->encoder_ids[i] == 0)
259 encoder = drm_encoder_find(connector->dev, NULL,
260 connector->encoder_ids[i]);
264 if ((encoder == best_encoder) && (status == connector_status_connected))
269 if (rdev->is_atom_bios)
270 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
272 radeon_combios_connected_scratch_regs(connector, encoder, connected);
277 static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
279 struct drm_encoder *encoder;
282 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
283 if (connector->encoder_ids[i] == 0)
286 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
290 if (encoder->encoder_type == encoder_type)
296 struct edid *radeon_connector_edid(struct drm_connector *connector)
298 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
299 struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
301 if (radeon_connector->edid) {
302 return radeon_connector->edid;
303 } else if (edid_blob) {
304 struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
306 radeon_connector->edid = edid;
308 return radeon_connector->edid;
311 static void radeon_connector_get_edid(struct drm_connector *connector)
313 struct drm_device *dev = connector->dev;
314 struct radeon_device *rdev = dev->dev_private;
315 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
317 if (radeon_connector->edid)
320 /* on hw with routers, select right port */
321 if (radeon_connector->router.ddc_valid)
322 radeon_router_select_ddc_port(radeon_connector);
324 if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
325 ENCODER_OBJECT_ID_NONE) &&
326 radeon_connector->ddc_bus->has_aux) {
327 radeon_connector->edid = drm_get_edid(connector,
328 &radeon_connector->ddc_bus->aux.ddc);
329 } else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
330 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
331 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
333 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
334 dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
335 radeon_connector->ddc_bus->has_aux)
336 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
337 &radeon_connector->ddc_bus->aux.ddc);
338 else if (radeon_connector->ddc_bus)
339 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
340 &radeon_connector->ddc_bus->adapter);
341 } else if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC &&
342 connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
343 radeon_connector->ddc_bus) {
344 radeon_connector->edid = drm_get_edid_switcheroo(&radeon_connector->base,
345 &radeon_connector->ddc_bus->adapter);
346 } else if (radeon_connector->ddc_bus) {
347 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
348 &radeon_connector->ddc_bus->adapter);
351 if (!radeon_connector->edid) {
352 /* don't fetch the edid from the vbios if ddc fails and runpm is
353 * enabled so we report disconnected.
355 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
358 if (rdev->is_atom_bios) {
359 /* some laptops provide a hardcoded edid in rom for LCDs */
360 if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
361 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
362 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
364 /* some servers provide a hardcoded edid in rom for KVMs */
365 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
370 static void radeon_connector_free_edid(struct drm_connector *connector)
372 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
374 if (radeon_connector->edid) {
375 kfree(radeon_connector->edid);
376 radeon_connector->edid = NULL;
380 static int radeon_ddc_get_modes(struct drm_connector *connector)
382 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
385 if (radeon_connector->edid) {
386 drm_mode_connector_update_edid_property(connector, radeon_connector->edid);
387 ret = drm_add_edid_modes(connector, radeon_connector->edid);
390 drm_mode_connector_update_edid_property(connector, NULL);
394 static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
396 int enc_id = connector->encoder_ids[0];
397 /* pick the encoder ids */
399 return drm_encoder_find(connector->dev, NULL, enc_id);
403 static void radeon_get_native_mode(struct drm_connector *connector)
405 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
406 struct radeon_encoder *radeon_encoder;
411 radeon_encoder = to_radeon_encoder(encoder);
413 if (!list_empty(&connector->probed_modes)) {
414 struct drm_display_mode *preferred_mode =
415 list_first_entry(&connector->probed_modes,
416 struct drm_display_mode, head);
418 radeon_encoder->native_mode = *preferred_mode;
420 radeon_encoder->native_mode.clock = 0;
425 * radeon_connector_analog_encoder_conflict_solve
426 * - search for other connectors sharing this encoder
427 * if priority is true, then set them disconnected if this is connected
428 * if priority is false, set us disconnected if they are connected
430 static enum drm_connector_status
431 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
432 struct drm_encoder *encoder,
433 enum drm_connector_status current_status,
436 struct drm_device *dev = connector->dev;
437 struct drm_connector *conflict;
438 struct radeon_connector *radeon_conflict;
441 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
442 if (conflict == connector)
445 radeon_conflict = to_radeon_connector(conflict);
446 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
447 if (conflict->encoder_ids[i] == 0)
450 /* if the IDs match */
451 if (conflict->encoder_ids[i] == encoder->base.id) {
452 if (conflict->status != connector_status_connected)
455 if (radeon_conflict->use_digital)
458 if (priority == true) {
459 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
461 DRM_DEBUG_KMS("in favor of %s\n",
463 conflict->status = connector_status_disconnected;
464 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
466 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
468 DRM_DEBUG_KMS("in favor of %s\n",
470 current_status = connector_status_disconnected;
476 return current_status;
480 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
482 struct drm_device *dev = encoder->dev;
483 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
484 struct drm_display_mode *mode = NULL;
485 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
487 if (native_mode->hdisplay != 0 &&
488 native_mode->vdisplay != 0 &&
489 native_mode->clock != 0) {
490 mode = drm_mode_duplicate(dev, native_mode);
491 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
492 drm_mode_set_name(mode);
494 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
495 } else if (native_mode->hdisplay != 0 &&
496 native_mode->vdisplay != 0) {
497 /* mac laptops without an edid */
498 /* Note that this is not necessarily the exact panel mode,
499 * but an approximation based on the cvt formula. For these
500 * systems we should ideally read the mode info out of the
501 * registers or add a mode table, but this works and is much
504 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
505 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
506 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
511 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
513 struct drm_device *dev = encoder->dev;
514 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
515 struct drm_display_mode *mode = NULL;
516 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
521 } common_modes[17] = {
541 for (i = 0; i < 17; i++) {
542 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
543 if (common_modes[i].w > 1024 ||
544 common_modes[i].h > 768)
547 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
548 if (common_modes[i].w > native_mode->hdisplay ||
549 common_modes[i].h > native_mode->vdisplay ||
550 (common_modes[i].w == native_mode->hdisplay &&
551 common_modes[i].h == native_mode->vdisplay))
554 if (common_modes[i].w < 320 || common_modes[i].h < 200)
557 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
558 drm_mode_probed_add(connector, mode);
562 static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
565 struct drm_device *dev = connector->dev;
566 struct radeon_device *rdev = dev->dev_private;
567 struct drm_encoder *encoder;
568 struct radeon_encoder *radeon_encoder;
570 if (property == rdev->mode_info.coherent_mode_property) {
571 struct radeon_encoder_atom_dig *dig;
572 bool new_coherent_mode;
574 /* need to find digital encoder on connector */
575 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
579 radeon_encoder = to_radeon_encoder(encoder);
581 if (!radeon_encoder->enc_priv)
584 dig = radeon_encoder->enc_priv;
585 new_coherent_mode = val ? true : false;
586 if (dig->coherent_mode != new_coherent_mode) {
587 dig->coherent_mode = new_coherent_mode;
588 radeon_property_change_mode(&radeon_encoder->base);
592 if (property == rdev->mode_info.audio_property) {
593 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
594 /* need to find digital encoder on connector */
595 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
599 radeon_encoder = to_radeon_encoder(encoder);
601 if (radeon_connector->audio != val) {
602 radeon_connector->audio = val;
603 radeon_property_change_mode(&radeon_encoder->base);
607 if (property == rdev->mode_info.dither_property) {
608 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
609 /* need to find digital encoder on connector */
610 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
614 radeon_encoder = to_radeon_encoder(encoder);
616 if (radeon_connector->dither != val) {
617 radeon_connector->dither = val;
618 radeon_property_change_mode(&radeon_encoder->base);
622 if (property == rdev->mode_info.underscan_property) {
623 /* need to find digital encoder on connector */
624 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
628 radeon_encoder = to_radeon_encoder(encoder);
630 if (radeon_encoder->underscan_type != val) {
631 radeon_encoder->underscan_type = val;
632 radeon_property_change_mode(&radeon_encoder->base);
636 if (property == rdev->mode_info.underscan_hborder_property) {
637 /* need to find digital encoder on connector */
638 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
642 radeon_encoder = to_radeon_encoder(encoder);
644 if (radeon_encoder->underscan_hborder != val) {
645 radeon_encoder->underscan_hborder = val;
646 radeon_property_change_mode(&radeon_encoder->base);
650 if (property == rdev->mode_info.underscan_vborder_property) {
651 /* need to find digital encoder on connector */
652 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
656 radeon_encoder = to_radeon_encoder(encoder);
658 if (radeon_encoder->underscan_vborder != val) {
659 radeon_encoder->underscan_vborder = val;
660 radeon_property_change_mode(&radeon_encoder->base);
664 if (property == rdev->mode_info.tv_std_property) {
665 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
667 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
673 radeon_encoder = to_radeon_encoder(encoder);
674 if (!radeon_encoder->enc_priv)
676 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
677 struct radeon_encoder_atom_dac *dac_int;
678 dac_int = radeon_encoder->enc_priv;
679 dac_int->tv_std = val;
681 struct radeon_encoder_tv_dac *dac_int;
682 dac_int = radeon_encoder->enc_priv;
683 dac_int->tv_std = val;
685 radeon_property_change_mode(&radeon_encoder->base);
688 if (property == rdev->mode_info.load_detect_property) {
689 struct radeon_connector *radeon_connector =
690 to_radeon_connector(connector);
693 radeon_connector->dac_load_detect = false;
695 radeon_connector->dac_load_detect = true;
698 if (property == rdev->mode_info.tmds_pll_property) {
699 struct radeon_encoder_int_tmds *tmds = NULL;
701 /* need to find digital encoder on connector */
702 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
706 radeon_encoder = to_radeon_encoder(encoder);
708 tmds = radeon_encoder->enc_priv;
713 if (rdev->is_atom_bios)
714 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
716 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
718 if (val == 1 || ret == false) {
719 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
721 radeon_property_change_mode(&radeon_encoder->base);
724 if (property == dev->mode_config.scaling_mode_property) {
725 enum radeon_rmx_type rmx_type;
727 if (connector->encoder)
728 radeon_encoder = to_radeon_encoder(connector->encoder);
730 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
731 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
736 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
737 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
738 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
739 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
741 if (radeon_encoder->rmx_type == rmx_type)
744 if ((rmx_type != DRM_MODE_SCALE_NONE) &&
745 (radeon_encoder->native_mode.clock == 0))
748 radeon_encoder->rmx_type = rmx_type;
750 radeon_property_change_mode(&radeon_encoder->base);
753 if (property == rdev->mode_info.output_csc_property) {
754 if (connector->encoder)
755 radeon_encoder = to_radeon_encoder(connector->encoder);
757 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
758 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
761 if (radeon_encoder->output_csc == val)
764 radeon_encoder->output_csc = val;
766 if (connector->encoder->crtc) {
767 struct drm_crtc *crtc = connector->encoder->crtc;
768 struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
770 radeon_crtc->output_csc = radeon_encoder->output_csc;
773 * Our .gamma_set assumes the .gamma_store has been
774 * prefilled and don't care about its arguments.
776 crtc->funcs->gamma_set(crtc, NULL, NULL, NULL, 0, NULL);
783 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
784 struct drm_connector *connector)
786 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
787 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
788 struct drm_display_mode *t, *mode;
790 /* If the EDID preferred mode doesn't match the native mode, use it */
791 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
792 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
793 if (mode->hdisplay != native_mode->hdisplay ||
794 mode->vdisplay != native_mode->vdisplay)
795 memcpy(native_mode, mode, sizeof(*mode));
799 /* Try to get native mode details from EDID if necessary */
800 if (!native_mode->clock) {
801 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
802 if (mode->hdisplay == native_mode->hdisplay &&
803 mode->vdisplay == native_mode->vdisplay) {
804 *native_mode = *mode;
805 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
806 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
812 if (!native_mode->clock) {
813 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
814 radeon_encoder->rmx_type = RMX_OFF;
818 static int radeon_lvds_get_modes(struct drm_connector *connector)
820 struct drm_encoder *encoder;
822 struct drm_display_mode *mode;
824 radeon_connector_get_edid(connector);
825 ret = radeon_ddc_get_modes(connector);
827 encoder = radeon_best_single_encoder(connector);
829 radeon_fixup_lvds_native_mode(encoder, connector);
830 /* add scaled modes */
831 radeon_add_common_modes(encoder, connector);
836 encoder = radeon_best_single_encoder(connector);
840 /* we have no EDID modes */
841 mode = radeon_fp_native_mode(encoder);
844 drm_mode_probed_add(connector, mode);
845 /* add the width/height from vbios tables if available */
846 connector->display_info.width_mm = mode->width_mm;
847 connector->display_info.height_mm = mode->height_mm;
848 /* add scaled modes */
849 radeon_add_common_modes(encoder, connector);
855 static enum drm_mode_status radeon_lvds_mode_valid(struct drm_connector *connector,
856 struct drm_display_mode *mode)
858 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
860 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
864 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
865 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
867 /* AVIVO hardware supports downscaling modes larger than the panel
868 * to the panel size, but I'm not sure this is desirable.
870 if ((mode->hdisplay > native_mode->hdisplay) ||
871 (mode->vdisplay > native_mode->vdisplay))
874 /* if scaling is disabled, block non-native modes */
875 if (radeon_encoder->rmx_type == RMX_OFF) {
876 if ((mode->hdisplay != native_mode->hdisplay) ||
877 (mode->vdisplay != native_mode->vdisplay))
885 static enum drm_connector_status
886 radeon_lvds_detect(struct drm_connector *connector, bool force)
888 struct drm_device *dev = connector->dev;
889 struct radeon_device *rdev = dev->dev_private;
890 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
891 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
892 enum drm_connector_status ret = connector_status_disconnected;
895 if (!drm_kms_helper_is_poll_worker()) {
896 r = pm_runtime_get_sync(connector->dev->dev);
898 return connector_status_disconnected;
902 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
903 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
905 /* check if panel is valid */
906 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
907 ret = connector_status_connected;
908 /* don't fetch the edid from the vbios if ddc fails and runpm is
909 * enabled so we report disconnected.
911 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
912 ret = connector_status_disconnected;
915 /* check for edid as well */
916 radeon_connector_get_edid(connector);
917 if (radeon_connector->edid)
918 ret = connector_status_connected;
919 /* check acpi lid status ??? */
921 radeon_connector_update_scratch_regs(connector, ret);
923 if (!drm_kms_helper_is_poll_worker()) {
924 pm_runtime_mark_last_busy(connector->dev->dev);
925 pm_runtime_put_autosuspend(connector->dev->dev);
931 static void radeon_connector_unregister(struct drm_connector *connector)
933 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
935 if (radeon_connector->ddc_bus && radeon_connector->ddc_bus->has_aux) {
936 drm_dp_aux_unregister(&radeon_connector->ddc_bus->aux);
937 radeon_connector->ddc_bus->has_aux = false;
941 static void radeon_connector_destroy(struct drm_connector *connector)
943 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
945 radeon_connector_free_edid(connector);
946 kfree(radeon_connector->con_priv);
947 drm_connector_unregister(connector);
948 drm_connector_cleanup(connector);
952 static int radeon_lvds_set_property(struct drm_connector *connector,
953 struct drm_property *property,
956 struct drm_device *dev = connector->dev;
957 struct radeon_encoder *radeon_encoder;
958 enum radeon_rmx_type rmx_type;
961 if (property != dev->mode_config.scaling_mode_property)
964 if (connector->encoder)
965 radeon_encoder = to_radeon_encoder(connector->encoder);
967 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
968 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
972 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
973 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
974 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
976 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
978 if (radeon_encoder->rmx_type == rmx_type)
981 radeon_encoder->rmx_type = rmx_type;
983 radeon_property_change_mode(&radeon_encoder->base);
988 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
989 .get_modes = radeon_lvds_get_modes,
990 .mode_valid = radeon_lvds_mode_valid,
991 .best_encoder = radeon_best_single_encoder,
994 static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
995 .dpms = drm_helper_connector_dpms,
996 .detect = radeon_lvds_detect,
997 .fill_modes = drm_helper_probe_single_connector_modes,
998 .early_unregister = radeon_connector_unregister,
999 .destroy = radeon_connector_destroy,
1000 .set_property = radeon_lvds_set_property,
1003 static int radeon_vga_get_modes(struct drm_connector *connector)
1007 radeon_connector_get_edid(connector);
1008 ret = radeon_ddc_get_modes(connector);
1010 radeon_get_native_mode(connector);
1015 static enum drm_mode_status radeon_vga_mode_valid(struct drm_connector *connector,
1016 struct drm_display_mode *mode)
1018 struct drm_device *dev = connector->dev;
1019 struct radeon_device *rdev = dev->dev_private;
1021 /* XXX check mode bandwidth */
1023 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1024 return MODE_CLOCK_HIGH;
1029 static enum drm_connector_status
1030 radeon_vga_detect(struct drm_connector *connector, bool force)
1032 struct drm_device *dev = connector->dev;
1033 struct radeon_device *rdev = dev->dev_private;
1034 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1035 struct drm_encoder *encoder;
1036 const struct drm_encoder_helper_funcs *encoder_funcs;
1038 enum drm_connector_status ret = connector_status_disconnected;
1041 if (!drm_kms_helper_is_poll_worker()) {
1042 r = pm_runtime_get_sync(connector->dev->dev);
1044 return connector_status_disconnected;
1047 encoder = radeon_best_single_encoder(connector);
1049 ret = connector_status_disconnected;
1051 if (radeon_connector->ddc_bus)
1052 dret = radeon_ddc_probe(radeon_connector, false);
1054 radeon_connector->detected_by_load = false;
1055 radeon_connector_free_edid(connector);
1056 radeon_connector_get_edid(connector);
1058 if (!radeon_connector->edid) {
1059 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1061 ret = connector_status_connected;
1063 radeon_connector->use_digital =
1064 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1066 /* some oems have boards with separate digital and analog connectors
1067 * with a shared ddc line (often vga + hdmi)
1069 if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
1070 radeon_connector_free_edid(connector);
1071 ret = connector_status_disconnected;
1073 ret = connector_status_connected;
1078 /* if we aren't forcing don't do destructive polling */
1080 /* only return the previous status if we last
1081 * detected a monitor via load.
1083 if (radeon_connector->detected_by_load)
1084 ret = connector->status;
1088 if (radeon_connector->dac_load_detect && encoder) {
1089 encoder_funcs = encoder->helper_private;
1090 ret = encoder_funcs->detect(encoder, connector);
1091 if (ret != connector_status_disconnected)
1092 radeon_connector->detected_by_load = true;
1096 if (ret == connector_status_connected)
1097 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1099 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1100 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1101 * by other means, assume the CRT is connected and use that EDID.
1103 if ((!rdev->is_atom_bios) &&
1104 (ret == connector_status_disconnected) &&
1105 rdev->mode_info.bios_hardcoded_edid_size) {
1106 ret = connector_status_connected;
1109 radeon_connector_update_scratch_regs(connector, ret);
1112 if (!drm_kms_helper_is_poll_worker()) {
1113 pm_runtime_mark_last_busy(connector->dev->dev);
1114 pm_runtime_put_autosuspend(connector->dev->dev);
1120 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
1121 .get_modes = radeon_vga_get_modes,
1122 .mode_valid = radeon_vga_mode_valid,
1123 .best_encoder = radeon_best_single_encoder,
1126 static const struct drm_connector_funcs radeon_vga_connector_funcs = {
1127 .dpms = drm_helper_connector_dpms,
1128 .detect = radeon_vga_detect,
1129 .fill_modes = drm_helper_probe_single_connector_modes,
1130 .early_unregister = radeon_connector_unregister,
1131 .destroy = radeon_connector_destroy,
1132 .set_property = radeon_connector_set_property,
1135 static int radeon_tv_get_modes(struct drm_connector *connector)
1137 struct drm_device *dev = connector->dev;
1138 struct radeon_device *rdev = dev->dev_private;
1139 struct drm_display_mode *tv_mode;
1140 struct drm_encoder *encoder;
1142 encoder = radeon_best_single_encoder(connector);
1146 /* avivo chips can scale any mode */
1147 if (rdev->family >= CHIP_RS600)
1148 /* add scaled modes */
1149 radeon_add_common_modes(encoder, connector);
1151 /* only 800x600 is supported right now on pre-avivo chips */
1152 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1153 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
1154 drm_mode_probed_add(connector, tv_mode);
1159 static enum drm_mode_status radeon_tv_mode_valid(struct drm_connector *connector,
1160 struct drm_display_mode *mode)
1162 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
1163 return MODE_CLOCK_RANGE;
1167 static enum drm_connector_status
1168 radeon_tv_detect(struct drm_connector *connector, bool force)
1170 struct drm_encoder *encoder;
1171 const struct drm_encoder_helper_funcs *encoder_funcs;
1172 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1173 enum drm_connector_status ret = connector_status_disconnected;
1176 if (!radeon_connector->dac_load_detect)
1179 if (!drm_kms_helper_is_poll_worker()) {
1180 r = pm_runtime_get_sync(connector->dev->dev);
1182 return connector_status_disconnected;
1185 encoder = radeon_best_single_encoder(connector);
1187 ret = connector_status_disconnected;
1189 encoder_funcs = encoder->helper_private;
1190 ret = encoder_funcs->detect(encoder, connector);
1192 if (ret == connector_status_connected)
1193 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
1194 radeon_connector_update_scratch_regs(connector, ret);
1196 if (!drm_kms_helper_is_poll_worker()) {
1197 pm_runtime_mark_last_busy(connector->dev->dev);
1198 pm_runtime_put_autosuspend(connector->dev->dev);
1204 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1205 .get_modes = radeon_tv_get_modes,
1206 .mode_valid = radeon_tv_mode_valid,
1207 .best_encoder = radeon_best_single_encoder,
1210 static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1211 .dpms = drm_helper_connector_dpms,
1212 .detect = radeon_tv_detect,
1213 .fill_modes = drm_helper_probe_single_connector_modes,
1214 .early_unregister = radeon_connector_unregister,
1215 .destroy = radeon_connector_destroy,
1216 .set_property = radeon_connector_set_property,
1219 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
1221 struct drm_device *dev = connector->dev;
1222 struct radeon_device *rdev = dev->dev_private;
1223 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1224 enum drm_connector_status status;
1226 /* We only trust HPD on R600 and newer ASICS. */
1227 if (rdev->family >= CHIP_R600
1228 && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
1229 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
1230 status = connector_status_connected;
1232 status = connector_status_disconnected;
1233 if (connector->status == status)
1241 * DVI is complicated
1242 * Do a DDC probe, if DDC probe passes, get the full EDID so
1243 * we can do analog/digital monitor detection at this point.
1244 * If the monitor is an analog monitor or we got no DDC,
1245 * we need to find the DAC encoder object for this connector.
1246 * If we got no DDC, we do load detection on the DAC encoder object.
1247 * If we got analog DDC or load detection passes on the DAC encoder
1248 * we have to check if this analog encoder is shared with anyone else (TV)
1249 * if its shared we have to set the other connector to disconnected.
1251 static enum drm_connector_status
1252 radeon_dvi_detect(struct drm_connector *connector, bool force)
1254 struct drm_device *dev = connector->dev;
1255 struct radeon_device *rdev = dev->dev_private;
1256 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1257 struct drm_encoder *encoder = NULL;
1258 const struct drm_encoder_helper_funcs *encoder_funcs;
1260 enum drm_connector_status ret = connector_status_disconnected;
1261 bool dret = false, broken_edid = false;
1263 if (!drm_kms_helper_is_poll_worker()) {
1264 r = pm_runtime_get_sync(connector->dev->dev);
1266 return connector_status_disconnected;
1269 if (radeon_connector->detected_hpd_without_ddc) {
1271 radeon_connector->detected_hpd_without_ddc = false;
1274 if (!force && radeon_check_hpd_status_unchanged(connector)) {
1275 ret = connector->status;
1279 if (radeon_connector->ddc_bus) {
1280 dret = radeon_ddc_probe(radeon_connector, false);
1282 /* Sometimes the pins required for the DDC probe on DVI
1283 * connectors don't make contact at the same time that the ones
1284 * for HPD do. If the DDC probe fails even though we had an HPD
1285 * signal, try again later */
1286 if (!dret && !force &&
1287 connector->status != connector_status_connected) {
1288 DRM_DEBUG_KMS("hpd detected without ddc, retrying in 1 second\n");
1289 radeon_connector->detected_hpd_without_ddc = true;
1290 schedule_delayed_work(&rdev->hotplug_work,
1291 msecs_to_jiffies(1000));
1296 radeon_connector->detected_by_load = false;
1297 radeon_connector_free_edid(connector);
1298 radeon_connector_get_edid(connector);
1300 if (!radeon_connector->edid) {
1301 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1303 /* rs690 seems to have a problem with connectors not existing and always
1304 * return a block of 0's. If we see this just stop polling on this output */
1305 if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
1306 radeon_connector->base.null_edid_counter) {
1307 ret = connector_status_disconnected;
1308 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1310 radeon_connector->ddc_bus = NULL;
1312 ret = connector_status_connected;
1313 broken_edid = true; /* defer use_digital to later */
1316 radeon_connector->use_digital =
1317 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1319 /* some oems have boards with separate digital and analog connectors
1320 * with a shared ddc line (often vga + hdmi)
1322 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
1323 radeon_connector_free_edid(connector);
1324 ret = connector_status_disconnected;
1326 ret = connector_status_connected;
1328 /* This gets complicated. We have boards with VGA + HDMI with a
1329 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1330 * DDC line. The latter is more complex because with DVI<->HDMI adapters
1331 * you don't really know what's connected to which port as both are digital.
1333 if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1334 struct drm_connector *list_connector;
1335 struct radeon_connector *list_radeon_connector;
1336 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
1337 if (connector == list_connector)
1339 list_radeon_connector = to_radeon_connector(list_connector);
1340 if (list_radeon_connector->shared_ddc &&
1341 (list_radeon_connector->ddc_bus->rec.i2c_id ==
1342 radeon_connector->ddc_bus->rec.i2c_id)) {
1343 /* cases where both connectors are digital */
1344 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1345 /* hpd is our only option in this case */
1346 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1347 radeon_connector_free_edid(connector);
1348 ret = connector_status_disconnected;
1357 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1360 /* DVI-D and HDMI-A are digital only */
1361 if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1362 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1365 /* if we aren't forcing don't do destructive polling */
1367 /* only return the previous status if we last
1368 * detected a monitor via load.
1370 if (radeon_connector->detected_by_load)
1371 ret = connector->status;
1375 /* find analog encoder */
1376 if (radeon_connector->dac_load_detect) {
1377 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1378 if (connector->encoder_ids[i] == 0)
1381 encoder = drm_encoder_find(connector->dev, NULL,
1382 connector->encoder_ids[i]);
1386 if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1387 encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1390 encoder_funcs = encoder->helper_private;
1391 if (encoder_funcs->detect) {
1393 if (ret != connector_status_connected) {
1394 /* deal with analog monitors without DDC */
1395 ret = encoder_funcs->detect(encoder, connector);
1396 if (ret == connector_status_connected) {
1397 radeon_connector->use_digital = false;
1399 if (ret != connector_status_disconnected)
1400 radeon_connector->detected_by_load = true;
1403 enum drm_connector_status lret;
1404 /* assume digital unless load detected otherwise */
1405 radeon_connector->use_digital = true;
1406 lret = encoder_funcs->detect(encoder, connector);
1407 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
1408 if (lret == connector_status_connected)
1409 radeon_connector->use_digital = false;
1416 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1418 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1421 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1422 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1423 * by other means, assume the DFP is connected and use that EDID. In most
1424 * cases the DVI port is actually a virtual KVM port connected to the service
1428 if ((!rdev->is_atom_bios) &&
1429 (ret == connector_status_disconnected) &&
1430 rdev->mode_info.bios_hardcoded_edid_size) {
1431 radeon_connector->use_digital = true;
1432 ret = connector_status_connected;
1435 /* updated in get modes as well since we need to know if it's analog or digital */
1436 radeon_connector_update_scratch_regs(connector, ret);
1438 if ((radeon_audio != 0) && radeon_connector->use_digital) {
1439 const struct drm_connector_helper_funcs *connector_funcs =
1440 connector->helper_private;
1442 encoder = connector_funcs->best_encoder(connector);
1443 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
1444 radeon_connector_get_edid(connector);
1445 radeon_audio_detect(connector, encoder, ret);
1450 if (!drm_kms_helper_is_poll_worker()) {
1451 pm_runtime_mark_last_busy(connector->dev->dev);
1452 pm_runtime_put_autosuspend(connector->dev->dev);
1458 /* okay need to be smart in here about which encoder to pick */
1459 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1461 int enc_id = connector->encoder_ids[0];
1462 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1463 struct drm_encoder *encoder;
1465 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1466 if (connector->encoder_ids[i] == 0)
1469 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
1473 if (radeon_connector->use_digital == true) {
1474 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1477 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1478 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1483 /* see if we have a default encoder TODO */
1485 /* then check use digitial */
1486 /* pick the first one */
1488 return drm_encoder_find(connector->dev, NULL, enc_id);
1492 static void radeon_dvi_force(struct drm_connector *connector)
1494 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1495 if (connector->force == DRM_FORCE_ON)
1496 radeon_connector->use_digital = false;
1497 if (connector->force == DRM_FORCE_ON_DIGITAL)
1498 radeon_connector->use_digital = true;
1501 static enum drm_mode_status radeon_dvi_mode_valid(struct drm_connector *connector,
1502 struct drm_display_mode *mode)
1504 struct drm_device *dev = connector->dev;
1505 struct radeon_device *rdev = dev->dev_private;
1506 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1508 /* XXX check mode bandwidth */
1510 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1511 if (radeon_connector->use_digital &&
1512 (rdev->family == CHIP_RV100) &&
1513 (mode->clock > 135000))
1514 return MODE_CLOCK_HIGH;
1516 if (radeon_connector->use_digital && (mode->clock > 165000)) {
1517 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1518 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1519 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1521 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1522 /* HDMI 1.3+ supports max clock of 340 Mhz */
1523 if (mode->clock > 340000)
1524 return MODE_CLOCK_HIGH;
1528 return MODE_CLOCK_HIGH;
1532 /* check against the max pixel clock */
1533 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1534 return MODE_CLOCK_HIGH;
1539 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1540 .get_modes = radeon_vga_get_modes,
1541 .mode_valid = radeon_dvi_mode_valid,
1542 .best_encoder = radeon_dvi_encoder,
1545 static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1546 .dpms = drm_helper_connector_dpms,
1547 .detect = radeon_dvi_detect,
1548 .fill_modes = drm_helper_probe_single_connector_modes,
1549 .set_property = radeon_connector_set_property,
1550 .early_unregister = radeon_connector_unregister,
1551 .destroy = radeon_connector_destroy,
1552 .force = radeon_dvi_force,
1555 static int radeon_dp_get_modes(struct drm_connector *connector)
1557 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1558 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1559 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1562 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1563 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1564 struct drm_display_mode *mode;
1566 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1567 if (!radeon_dig_connector->edp_on)
1568 atombios_set_edp_panel_power(connector,
1569 ATOM_TRANSMITTER_ACTION_POWER_ON);
1570 radeon_connector_get_edid(connector);
1571 ret = radeon_ddc_get_modes(connector);
1572 if (!radeon_dig_connector->edp_on)
1573 atombios_set_edp_panel_power(connector,
1574 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1576 /* need to setup ddc on the bridge */
1577 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1578 ENCODER_OBJECT_ID_NONE) {
1580 radeon_atom_ext_encoder_setup_ddc(encoder);
1582 radeon_connector_get_edid(connector);
1583 ret = radeon_ddc_get_modes(connector);
1588 radeon_fixup_lvds_native_mode(encoder, connector);
1589 /* add scaled modes */
1590 radeon_add_common_modes(encoder, connector);
1598 /* we have no EDID modes */
1599 mode = radeon_fp_native_mode(encoder);
1602 drm_mode_probed_add(connector, mode);
1603 /* add the width/height from vbios tables if available */
1604 connector->display_info.width_mm = mode->width_mm;
1605 connector->display_info.height_mm = mode->height_mm;
1606 /* add scaled modes */
1607 radeon_add_common_modes(encoder, connector);
1610 /* need to setup ddc on the bridge */
1611 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1612 ENCODER_OBJECT_ID_NONE) {
1614 radeon_atom_ext_encoder_setup_ddc(encoder);
1616 radeon_connector_get_edid(connector);
1617 ret = radeon_ddc_get_modes(connector);
1619 radeon_get_native_mode(connector);
1625 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1627 struct drm_encoder *encoder;
1628 struct radeon_encoder *radeon_encoder;
1631 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1632 if (connector->encoder_ids[i] == 0)
1635 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
1639 radeon_encoder = to_radeon_encoder(encoder);
1641 switch (radeon_encoder->encoder_id) {
1642 case ENCODER_OBJECT_ID_TRAVIS:
1643 case ENCODER_OBJECT_ID_NUTMEG:
1644 return radeon_encoder->encoder_id;
1650 return ENCODER_OBJECT_ID_NONE;
1653 static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1655 struct drm_encoder *encoder;
1656 struct radeon_encoder *radeon_encoder;
1660 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1661 if (connector->encoder_ids[i] == 0)
1664 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
1668 radeon_encoder = to_radeon_encoder(encoder);
1669 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1676 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1678 struct drm_device *dev = connector->dev;
1679 struct radeon_device *rdev = dev->dev_private;
1681 if (ASIC_IS_DCE5(rdev) &&
1682 (rdev->clock.default_dispclk >= 53900) &&
1683 radeon_connector_encoder_is_hbr2(connector)) {
1690 static enum drm_connector_status
1691 radeon_dp_detect(struct drm_connector *connector, bool force)
1693 struct drm_device *dev = connector->dev;
1694 struct radeon_device *rdev = dev->dev_private;
1695 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1696 enum drm_connector_status ret = connector_status_disconnected;
1697 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1698 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1701 if (radeon_dig_connector->is_mst)
1702 return connector_status_disconnected;
1704 if (!drm_kms_helper_is_poll_worker()) {
1705 r = pm_runtime_get_sync(connector->dev->dev);
1707 return connector_status_disconnected;
1710 if (!force && radeon_check_hpd_status_unchanged(connector)) {
1711 ret = connector->status;
1715 radeon_connector_free_edid(connector);
1717 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1718 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1720 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1721 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1723 /* check if panel is valid */
1724 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1725 ret = connector_status_connected;
1726 /* don't fetch the edid from the vbios if ddc fails and runpm is
1727 * enabled so we report disconnected.
1729 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
1730 ret = connector_status_disconnected;
1732 /* eDP is always DP */
1733 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1734 if (!radeon_dig_connector->edp_on)
1735 atombios_set_edp_panel_power(connector,
1736 ATOM_TRANSMITTER_ACTION_POWER_ON);
1737 if (radeon_dp_getdpcd(radeon_connector))
1738 ret = connector_status_connected;
1739 if (!radeon_dig_connector->edp_on)
1740 atombios_set_edp_panel_power(connector,
1741 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1742 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1743 ENCODER_OBJECT_ID_NONE) {
1744 /* DP bridges are always DP */
1745 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1746 /* get the DPCD from the bridge */
1747 radeon_dp_getdpcd(radeon_connector);
1750 /* setup ddc on the bridge */
1751 radeon_atom_ext_encoder_setup_ddc(encoder);
1752 /* bridge chips are always aux */
1753 if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
1754 ret = connector_status_connected;
1755 else if (radeon_connector->dac_load_detect) { /* try load detection */
1756 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1757 ret = encoder_funcs->detect(encoder, connector);
1761 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1762 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1763 ret = connector_status_connected;
1764 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1765 radeon_dp_getdpcd(radeon_connector);
1766 r = radeon_dp_mst_probe(radeon_connector);
1768 ret = connector_status_disconnected;
1771 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1772 if (radeon_dp_getdpcd(radeon_connector)) {
1773 r = radeon_dp_mst_probe(radeon_connector);
1775 ret = connector_status_disconnected;
1777 ret = connector_status_connected;
1780 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1781 if (radeon_ddc_probe(radeon_connector, false))
1782 ret = connector_status_connected;
1787 radeon_connector_update_scratch_regs(connector, ret);
1789 if ((radeon_audio != 0) && encoder) {
1790 radeon_connector_get_edid(connector);
1791 radeon_audio_detect(connector, encoder, ret);
1795 if (!drm_kms_helper_is_poll_worker()) {
1796 pm_runtime_mark_last_busy(connector->dev->dev);
1797 pm_runtime_put_autosuspend(connector->dev->dev);
1803 static enum drm_mode_status radeon_dp_mode_valid(struct drm_connector *connector,
1804 struct drm_display_mode *mode)
1806 struct drm_device *dev = connector->dev;
1807 struct radeon_device *rdev = dev->dev_private;
1808 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1809 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1811 /* XXX check mode bandwidth */
1813 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1814 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1815 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1817 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1821 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1822 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1824 /* AVIVO hardware supports downscaling modes larger than the panel
1825 * to the panel size, but I'm not sure this is desirable.
1827 if ((mode->hdisplay > native_mode->hdisplay) ||
1828 (mode->vdisplay > native_mode->vdisplay))
1831 /* if scaling is disabled, block non-native modes */
1832 if (radeon_encoder->rmx_type == RMX_OFF) {
1833 if ((mode->hdisplay != native_mode->hdisplay) ||
1834 (mode->vdisplay != native_mode->vdisplay))
1839 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1840 (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1841 return radeon_dp_mode_valid_helper(connector, mode);
1843 if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1844 /* HDMI 1.3+ supports max clock of 340 Mhz */
1845 if (mode->clock > 340000)
1846 return MODE_CLOCK_HIGH;
1848 if (mode->clock > 165000)
1849 return MODE_CLOCK_HIGH;
1857 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1858 .get_modes = radeon_dp_get_modes,
1859 .mode_valid = radeon_dp_mode_valid,
1860 .best_encoder = radeon_dvi_encoder,
1863 static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1864 .dpms = drm_helper_connector_dpms,
1865 .detect = radeon_dp_detect,
1866 .fill_modes = drm_helper_probe_single_connector_modes,
1867 .set_property = radeon_connector_set_property,
1868 .early_unregister = radeon_connector_unregister,
1869 .destroy = radeon_connector_destroy,
1870 .force = radeon_dvi_force,
1873 static const struct drm_connector_funcs radeon_edp_connector_funcs = {
1874 .dpms = drm_helper_connector_dpms,
1875 .detect = radeon_dp_detect,
1876 .fill_modes = drm_helper_probe_single_connector_modes,
1877 .set_property = radeon_lvds_set_property,
1878 .early_unregister = radeon_connector_unregister,
1879 .destroy = radeon_connector_destroy,
1880 .force = radeon_dvi_force,
1883 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
1884 .dpms = drm_helper_connector_dpms,
1885 .detect = radeon_dp_detect,
1886 .fill_modes = drm_helper_probe_single_connector_modes,
1887 .set_property = radeon_lvds_set_property,
1888 .early_unregister = radeon_connector_unregister,
1889 .destroy = radeon_connector_destroy,
1890 .force = radeon_dvi_force,
1894 radeon_add_atom_connector(struct drm_device *dev,
1895 uint32_t connector_id,
1896 uint32_t supported_device,
1898 struct radeon_i2c_bus_rec *i2c_bus,
1899 uint32_t igp_lane_info,
1900 uint16_t connector_object_id,
1901 struct radeon_hpd *hpd,
1902 struct radeon_router *router)
1904 struct radeon_device *rdev = dev->dev_private;
1905 struct drm_connector *connector;
1906 struct radeon_connector *radeon_connector;
1907 struct radeon_connector_atom_dig *radeon_dig_connector;
1908 struct drm_encoder *encoder;
1909 struct radeon_encoder *radeon_encoder;
1910 uint32_t subpixel_order = SubPixelNone;
1911 bool shared_ddc = false;
1912 bool is_dp_bridge = false;
1913 bool has_aux = false;
1915 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1918 /* if the user selected tv=0 don't try and add the connector */
1919 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1920 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1921 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1925 /* see if we already added it */
1926 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1927 radeon_connector = to_radeon_connector(connector);
1928 if (radeon_connector->connector_id == connector_id) {
1929 radeon_connector->devices |= supported_device;
1932 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1933 if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1934 radeon_connector->shared_ddc = true;
1937 if (radeon_connector->router_bus && router->ddc_valid &&
1938 (radeon_connector->router.router_id == router->router_id)) {
1939 radeon_connector->shared_ddc = false;
1945 /* check if it's a dp bridge */
1946 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1947 radeon_encoder = to_radeon_encoder(encoder);
1948 if (radeon_encoder->devices & supported_device) {
1949 switch (radeon_encoder->encoder_id) {
1950 case ENCODER_OBJECT_ID_TRAVIS:
1951 case ENCODER_OBJECT_ID_NUTMEG:
1952 is_dp_bridge = true;
1960 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1961 if (!radeon_connector)
1964 connector = &radeon_connector->base;
1966 radeon_connector->connector_id = connector_id;
1967 radeon_connector->devices = supported_device;
1968 radeon_connector->shared_ddc = shared_ddc;
1969 radeon_connector->connector_object_id = connector_object_id;
1970 radeon_connector->hpd = *hpd;
1972 radeon_connector->router = *router;
1973 if (router->ddc_valid || router->cd_valid) {
1974 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1975 if (!radeon_connector->router_bus)
1976 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1980 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1981 if (!radeon_dig_connector)
1983 radeon_dig_connector->igp_lane_info = igp_lane_info;
1984 radeon_connector->con_priv = radeon_dig_connector;
1985 if (i2c_bus->valid) {
1986 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1987 if (radeon_connector->ddc_bus)
1990 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1992 switch (connector_type) {
1993 case DRM_MODE_CONNECTOR_VGA:
1994 case DRM_MODE_CONNECTOR_DVIA:
1996 drm_connector_init(dev, &radeon_connector->base,
1997 &radeon_dp_connector_funcs, connector_type);
1998 drm_connector_helper_add(&radeon_connector->base,
1999 &radeon_dp_connector_helper_funcs);
2000 connector->interlace_allowed = true;
2001 connector->doublescan_allowed = true;
2002 radeon_connector->dac_load_detect = true;
2003 drm_object_attach_property(&radeon_connector->base.base,
2004 rdev->mode_info.load_detect_property,
2006 drm_object_attach_property(&radeon_connector->base.base,
2007 dev->mode_config.scaling_mode_property,
2008 DRM_MODE_SCALE_NONE);
2009 if (ASIC_IS_DCE5(rdev))
2010 drm_object_attach_property(&radeon_connector->base.base,
2011 rdev->mode_info.output_csc_property,
2012 RADEON_OUTPUT_CSC_BYPASS);
2014 case DRM_MODE_CONNECTOR_DVII:
2015 case DRM_MODE_CONNECTOR_DVID:
2016 case DRM_MODE_CONNECTOR_HDMIA:
2017 case DRM_MODE_CONNECTOR_HDMIB:
2018 case DRM_MODE_CONNECTOR_DisplayPort:
2019 drm_connector_init(dev, &radeon_connector->base,
2020 &radeon_dp_connector_funcs, connector_type);
2021 drm_connector_helper_add(&radeon_connector->base,
2022 &radeon_dp_connector_helper_funcs);
2023 drm_object_attach_property(&radeon_connector->base.base,
2024 rdev->mode_info.underscan_property,
2026 drm_object_attach_property(&radeon_connector->base.base,
2027 rdev->mode_info.underscan_hborder_property,
2029 drm_object_attach_property(&radeon_connector->base.base,
2030 rdev->mode_info.underscan_vborder_property,
2033 drm_object_attach_property(&radeon_connector->base.base,
2034 dev->mode_config.scaling_mode_property,
2035 DRM_MODE_SCALE_NONE);
2037 drm_object_attach_property(&radeon_connector->base.base,
2038 rdev->mode_info.dither_property,
2039 RADEON_FMT_DITHER_DISABLE);
2041 if (radeon_audio != 0) {
2042 drm_object_attach_property(&radeon_connector->base.base,
2043 rdev->mode_info.audio_property,
2045 radeon_connector->audio = RADEON_AUDIO_AUTO;
2047 if (ASIC_IS_DCE5(rdev))
2048 drm_object_attach_property(&radeon_connector->base.base,
2049 rdev->mode_info.output_csc_property,
2050 RADEON_OUTPUT_CSC_BYPASS);
2052 subpixel_order = SubPixelHorizontalRGB;
2053 connector->interlace_allowed = true;
2054 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2055 connector->doublescan_allowed = true;
2057 connector->doublescan_allowed = false;
2058 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2059 radeon_connector->dac_load_detect = true;
2060 drm_object_attach_property(&radeon_connector->base.base,
2061 rdev->mode_info.load_detect_property,
2065 case DRM_MODE_CONNECTOR_LVDS:
2066 case DRM_MODE_CONNECTOR_eDP:
2067 drm_connector_init(dev, &radeon_connector->base,
2068 &radeon_lvds_bridge_connector_funcs, connector_type);
2069 drm_connector_helper_add(&radeon_connector->base,
2070 &radeon_dp_connector_helper_funcs);
2071 drm_object_attach_property(&radeon_connector->base.base,
2072 dev->mode_config.scaling_mode_property,
2073 DRM_MODE_SCALE_FULLSCREEN);
2074 subpixel_order = SubPixelHorizontalRGB;
2075 connector->interlace_allowed = false;
2076 connector->doublescan_allowed = false;
2080 switch (connector_type) {
2081 case DRM_MODE_CONNECTOR_VGA:
2082 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2083 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2084 if (i2c_bus->valid) {
2085 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2086 if (!radeon_connector->ddc_bus)
2087 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2089 radeon_connector->dac_load_detect = true;
2090 drm_object_attach_property(&radeon_connector->base.base,
2091 rdev->mode_info.load_detect_property,
2093 if (ASIC_IS_AVIVO(rdev))
2094 drm_object_attach_property(&radeon_connector->base.base,
2095 dev->mode_config.scaling_mode_property,
2096 DRM_MODE_SCALE_NONE);
2097 if (ASIC_IS_DCE5(rdev))
2098 drm_object_attach_property(&radeon_connector->base.base,
2099 rdev->mode_info.output_csc_property,
2100 RADEON_OUTPUT_CSC_BYPASS);
2101 /* no HPD on analog connectors */
2102 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2103 connector->interlace_allowed = true;
2104 connector->doublescan_allowed = true;
2106 case DRM_MODE_CONNECTOR_DVIA:
2107 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2108 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2109 if (i2c_bus->valid) {
2110 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2111 if (!radeon_connector->ddc_bus)
2112 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2114 radeon_connector->dac_load_detect = true;
2115 drm_object_attach_property(&radeon_connector->base.base,
2116 rdev->mode_info.load_detect_property,
2118 if (ASIC_IS_AVIVO(rdev))
2119 drm_object_attach_property(&radeon_connector->base.base,
2120 dev->mode_config.scaling_mode_property,
2121 DRM_MODE_SCALE_NONE);
2122 if (ASIC_IS_DCE5(rdev))
2123 drm_object_attach_property(&radeon_connector->base.base,
2124 rdev->mode_info.output_csc_property,
2125 RADEON_OUTPUT_CSC_BYPASS);
2126 /* no HPD on analog connectors */
2127 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2128 connector->interlace_allowed = true;
2129 connector->doublescan_allowed = true;
2131 case DRM_MODE_CONNECTOR_DVII:
2132 case DRM_MODE_CONNECTOR_DVID:
2133 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2134 if (!radeon_dig_connector)
2136 radeon_dig_connector->igp_lane_info = igp_lane_info;
2137 radeon_connector->con_priv = radeon_dig_connector;
2138 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2139 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2140 if (i2c_bus->valid) {
2141 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2142 if (!radeon_connector->ddc_bus)
2143 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2145 subpixel_order = SubPixelHorizontalRGB;
2146 drm_object_attach_property(&radeon_connector->base.base,
2147 rdev->mode_info.coherent_mode_property,
2149 if (ASIC_IS_AVIVO(rdev)) {
2150 drm_object_attach_property(&radeon_connector->base.base,
2151 rdev->mode_info.underscan_property,
2153 drm_object_attach_property(&radeon_connector->base.base,
2154 rdev->mode_info.underscan_hborder_property,
2156 drm_object_attach_property(&radeon_connector->base.base,
2157 rdev->mode_info.underscan_vborder_property,
2159 drm_object_attach_property(&radeon_connector->base.base,
2160 rdev->mode_info.dither_property,
2161 RADEON_FMT_DITHER_DISABLE);
2162 drm_object_attach_property(&radeon_connector->base.base,
2163 dev->mode_config.scaling_mode_property,
2164 DRM_MODE_SCALE_NONE);
2166 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2167 drm_object_attach_property(&radeon_connector->base.base,
2168 rdev->mode_info.audio_property,
2170 radeon_connector->audio = RADEON_AUDIO_AUTO;
2172 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2173 radeon_connector->dac_load_detect = true;
2174 drm_object_attach_property(&radeon_connector->base.base,
2175 rdev->mode_info.load_detect_property,
2178 if (ASIC_IS_DCE5(rdev))
2179 drm_object_attach_property(&radeon_connector->base.base,
2180 rdev->mode_info.output_csc_property,
2181 RADEON_OUTPUT_CSC_BYPASS);
2182 connector->interlace_allowed = true;
2183 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2184 connector->doublescan_allowed = true;
2186 connector->doublescan_allowed = false;
2188 case DRM_MODE_CONNECTOR_HDMIA:
2189 case DRM_MODE_CONNECTOR_HDMIB:
2190 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2191 if (!radeon_dig_connector)
2193 radeon_dig_connector->igp_lane_info = igp_lane_info;
2194 radeon_connector->con_priv = radeon_dig_connector;
2195 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2196 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2197 if (i2c_bus->valid) {
2198 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2199 if (!radeon_connector->ddc_bus)
2200 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2202 drm_object_attach_property(&radeon_connector->base.base,
2203 rdev->mode_info.coherent_mode_property,
2205 if (ASIC_IS_AVIVO(rdev)) {
2206 drm_object_attach_property(&radeon_connector->base.base,
2207 rdev->mode_info.underscan_property,
2209 drm_object_attach_property(&radeon_connector->base.base,
2210 rdev->mode_info.underscan_hborder_property,
2212 drm_object_attach_property(&radeon_connector->base.base,
2213 rdev->mode_info.underscan_vborder_property,
2215 drm_object_attach_property(&radeon_connector->base.base,
2216 rdev->mode_info.dither_property,
2217 RADEON_FMT_DITHER_DISABLE);
2218 drm_object_attach_property(&radeon_connector->base.base,
2219 dev->mode_config.scaling_mode_property,
2220 DRM_MODE_SCALE_NONE);
2222 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2223 drm_object_attach_property(&radeon_connector->base.base,
2224 rdev->mode_info.audio_property,
2226 radeon_connector->audio = RADEON_AUDIO_AUTO;
2228 if (ASIC_IS_DCE5(rdev))
2229 drm_object_attach_property(&radeon_connector->base.base,
2230 rdev->mode_info.output_csc_property,
2231 RADEON_OUTPUT_CSC_BYPASS);
2232 subpixel_order = SubPixelHorizontalRGB;
2233 connector->interlace_allowed = true;
2234 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2235 connector->doublescan_allowed = true;
2237 connector->doublescan_allowed = false;
2239 case DRM_MODE_CONNECTOR_DisplayPort:
2240 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2241 if (!radeon_dig_connector)
2243 radeon_dig_connector->igp_lane_info = igp_lane_info;
2244 radeon_connector->con_priv = radeon_dig_connector;
2245 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
2246 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2247 if (i2c_bus->valid) {
2248 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2249 if (radeon_connector->ddc_bus)
2252 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2254 subpixel_order = SubPixelHorizontalRGB;
2255 drm_object_attach_property(&radeon_connector->base.base,
2256 rdev->mode_info.coherent_mode_property,
2258 if (ASIC_IS_AVIVO(rdev)) {
2259 drm_object_attach_property(&radeon_connector->base.base,
2260 rdev->mode_info.underscan_property,
2262 drm_object_attach_property(&radeon_connector->base.base,
2263 rdev->mode_info.underscan_hborder_property,
2265 drm_object_attach_property(&radeon_connector->base.base,
2266 rdev->mode_info.underscan_vborder_property,
2268 drm_object_attach_property(&radeon_connector->base.base,
2269 rdev->mode_info.dither_property,
2270 RADEON_FMT_DITHER_DISABLE);
2271 drm_object_attach_property(&radeon_connector->base.base,
2272 dev->mode_config.scaling_mode_property,
2273 DRM_MODE_SCALE_NONE);
2275 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2276 drm_object_attach_property(&radeon_connector->base.base,
2277 rdev->mode_info.audio_property,
2279 radeon_connector->audio = RADEON_AUDIO_AUTO;
2281 if (ASIC_IS_DCE5(rdev))
2282 drm_object_attach_property(&radeon_connector->base.base,
2283 rdev->mode_info.output_csc_property,
2284 RADEON_OUTPUT_CSC_BYPASS);
2285 connector->interlace_allowed = true;
2286 /* in theory with a DP to VGA converter... */
2287 connector->doublescan_allowed = false;
2289 case DRM_MODE_CONNECTOR_eDP:
2290 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2291 if (!radeon_dig_connector)
2293 radeon_dig_connector->igp_lane_info = igp_lane_info;
2294 radeon_connector->con_priv = radeon_dig_connector;
2295 drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
2296 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2297 if (i2c_bus->valid) {
2298 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2299 if (radeon_connector->ddc_bus)
2302 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2304 drm_object_attach_property(&radeon_connector->base.base,
2305 dev->mode_config.scaling_mode_property,
2306 DRM_MODE_SCALE_FULLSCREEN);
2307 subpixel_order = SubPixelHorizontalRGB;
2308 connector->interlace_allowed = false;
2309 connector->doublescan_allowed = false;
2311 case DRM_MODE_CONNECTOR_SVIDEO:
2312 case DRM_MODE_CONNECTOR_Composite:
2313 case DRM_MODE_CONNECTOR_9PinDIN:
2314 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2315 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2316 radeon_connector->dac_load_detect = true;
2317 drm_object_attach_property(&radeon_connector->base.base,
2318 rdev->mode_info.load_detect_property,
2320 drm_object_attach_property(&radeon_connector->base.base,
2321 rdev->mode_info.tv_std_property,
2322 radeon_atombios_get_tv_info(rdev));
2323 /* no HPD on analog connectors */
2324 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2325 connector->interlace_allowed = false;
2326 connector->doublescan_allowed = false;
2328 case DRM_MODE_CONNECTOR_LVDS:
2329 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2330 if (!radeon_dig_connector)
2332 radeon_dig_connector->igp_lane_info = igp_lane_info;
2333 radeon_connector->con_priv = radeon_dig_connector;
2334 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2335 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2336 if (i2c_bus->valid) {
2337 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2338 if (!radeon_connector->ddc_bus)
2339 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2341 drm_object_attach_property(&radeon_connector->base.base,
2342 dev->mode_config.scaling_mode_property,
2343 DRM_MODE_SCALE_FULLSCREEN);
2344 subpixel_order = SubPixelHorizontalRGB;
2345 connector->interlace_allowed = false;
2346 connector->doublescan_allowed = false;
2351 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2352 if (i2c_bus->valid) {
2353 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2354 DRM_CONNECTOR_POLL_DISCONNECT;
2357 connector->polled = DRM_CONNECTOR_POLL_HPD;
2359 connector->display_info.subpixel_order = subpixel_order;
2360 drm_connector_register(connector);
2363 radeon_dp_aux_init(radeon_connector);
2368 drm_connector_cleanup(connector);
2373 radeon_add_legacy_connector(struct drm_device *dev,
2374 uint32_t connector_id,
2375 uint32_t supported_device,
2377 struct radeon_i2c_bus_rec *i2c_bus,
2378 uint16_t connector_object_id,
2379 struct radeon_hpd *hpd)
2381 struct radeon_device *rdev = dev->dev_private;
2382 struct drm_connector *connector;
2383 struct radeon_connector *radeon_connector;
2384 uint32_t subpixel_order = SubPixelNone;
2386 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
2389 /* if the user selected tv=0 don't try and add the connector */
2390 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
2391 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
2392 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
2396 /* see if we already added it */
2397 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2398 radeon_connector = to_radeon_connector(connector);
2399 if (radeon_connector->connector_id == connector_id) {
2400 radeon_connector->devices |= supported_device;
2405 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
2406 if (!radeon_connector)
2409 connector = &radeon_connector->base;
2411 radeon_connector->connector_id = connector_id;
2412 radeon_connector->devices = supported_device;
2413 radeon_connector->connector_object_id = connector_object_id;
2414 radeon_connector->hpd = *hpd;
2416 switch (connector_type) {
2417 case DRM_MODE_CONNECTOR_VGA:
2418 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2419 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2420 if (i2c_bus->valid) {
2421 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2422 if (!radeon_connector->ddc_bus)
2423 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2425 radeon_connector->dac_load_detect = true;
2426 drm_object_attach_property(&radeon_connector->base.base,
2427 rdev->mode_info.load_detect_property,
2429 /* no HPD on analog connectors */
2430 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2431 connector->interlace_allowed = true;
2432 connector->doublescan_allowed = true;
2434 case DRM_MODE_CONNECTOR_DVIA:
2435 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2436 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2437 if (i2c_bus->valid) {
2438 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2439 if (!radeon_connector->ddc_bus)
2440 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2442 radeon_connector->dac_load_detect = true;
2443 drm_object_attach_property(&radeon_connector->base.base,
2444 rdev->mode_info.load_detect_property,
2446 /* no HPD on analog connectors */
2447 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2448 connector->interlace_allowed = true;
2449 connector->doublescan_allowed = true;
2451 case DRM_MODE_CONNECTOR_DVII:
2452 case DRM_MODE_CONNECTOR_DVID:
2453 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2454 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2455 if (i2c_bus->valid) {
2456 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2457 if (!radeon_connector->ddc_bus)
2458 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2460 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2461 radeon_connector->dac_load_detect = true;
2462 drm_object_attach_property(&radeon_connector->base.base,
2463 rdev->mode_info.load_detect_property,
2466 subpixel_order = SubPixelHorizontalRGB;
2467 connector->interlace_allowed = true;
2468 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2469 connector->doublescan_allowed = true;
2471 connector->doublescan_allowed = false;
2473 case DRM_MODE_CONNECTOR_SVIDEO:
2474 case DRM_MODE_CONNECTOR_Composite:
2475 case DRM_MODE_CONNECTOR_9PinDIN:
2476 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2477 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2478 radeon_connector->dac_load_detect = true;
2479 /* RS400,RC410,RS480 chipset seems to report a lot
2480 * of false positive on load detect, we haven't yet
2481 * found a way to make load detect reliable on those
2482 * chipset, thus just disable it for TV.
2484 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
2485 radeon_connector->dac_load_detect = false;
2486 drm_object_attach_property(&radeon_connector->base.base,
2487 rdev->mode_info.load_detect_property,
2488 radeon_connector->dac_load_detect);
2489 drm_object_attach_property(&radeon_connector->base.base,
2490 rdev->mode_info.tv_std_property,
2491 radeon_combios_get_tv_info(rdev));
2492 /* no HPD on analog connectors */
2493 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2494 connector->interlace_allowed = false;
2495 connector->doublescan_allowed = false;
2497 case DRM_MODE_CONNECTOR_LVDS:
2498 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2499 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2500 if (i2c_bus->valid) {
2501 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2502 if (!radeon_connector->ddc_bus)
2503 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2505 drm_object_attach_property(&radeon_connector->base.base,
2506 dev->mode_config.scaling_mode_property,
2507 DRM_MODE_SCALE_FULLSCREEN);
2508 subpixel_order = SubPixelHorizontalRGB;
2509 connector->interlace_allowed = false;
2510 connector->doublescan_allowed = false;
2514 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2515 if (i2c_bus->valid) {
2516 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2517 DRM_CONNECTOR_POLL_DISCONNECT;
2520 connector->polled = DRM_CONNECTOR_POLL_HPD;
2522 connector->display_info.subpixel_order = subpixel_order;
2523 drm_connector_register(connector);
2526 void radeon_setup_mst_connector(struct drm_device *dev)
2528 struct radeon_device *rdev = dev->dev_private;
2529 struct drm_connector *connector;
2530 struct radeon_connector *radeon_connector;
2532 if (!ASIC_IS_DCE5(rdev))
2535 if (radeon_mst == 0)
2538 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2541 radeon_connector = to_radeon_connector(connector);
2543 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
2546 ret = radeon_dp_mst_init(radeon_connector);