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 int saved_dpms = connector->dpms;
95 /* Only turn off the display if it's physically disconnected */
96 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
97 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
98 } else if (radeon_dp_needs_link_train(radeon_connector)) {
99 /* Don't try to start link training before we
101 if (!radeon_dp_getdpcd(radeon_connector))
104 /* set it to OFF so that drm_helper_connector_dpms()
105 * won't return immediately since the current state
106 * is ON at this point.
108 connector->dpms = DRM_MODE_DPMS_OFF;
109 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
111 connector->dpms = saved_dpms;
116 static void radeon_property_change_mode(struct drm_encoder *encoder)
118 struct drm_crtc *crtc = encoder->crtc;
120 if (crtc && crtc->enabled) {
121 drm_crtc_helper_set_mode(crtc, &crtc->mode,
122 crtc->x, crtc->y, crtc->primary->fb);
126 int radeon_get_monitor_bpc(struct drm_connector *connector)
128 struct drm_device *dev = connector->dev;
129 struct radeon_device *rdev = dev->dev_private;
130 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
131 struct radeon_connector_atom_dig *dig_connector;
133 int mode_clock, max_tmds_clock;
135 switch (connector->connector_type) {
136 case DRM_MODE_CONNECTOR_DVII:
137 case DRM_MODE_CONNECTOR_HDMIB:
138 if (radeon_connector->use_digital) {
139 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
140 if (connector->display_info.bpc)
141 bpc = connector->display_info.bpc;
145 case DRM_MODE_CONNECTOR_DVID:
146 case DRM_MODE_CONNECTOR_HDMIA:
147 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
148 if (connector->display_info.bpc)
149 bpc = connector->display_info.bpc;
152 case DRM_MODE_CONNECTOR_DisplayPort:
153 dig_connector = radeon_connector->con_priv;
154 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
155 (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
156 drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
157 if (connector->display_info.bpc)
158 bpc = connector->display_info.bpc;
161 case DRM_MODE_CONNECTOR_eDP:
162 case DRM_MODE_CONNECTOR_LVDS:
163 if (connector->display_info.bpc)
164 bpc = connector->display_info.bpc;
165 else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
166 const struct drm_connector_helper_funcs *connector_funcs =
167 connector->helper_private;
168 struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
169 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
170 struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
172 if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
174 else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
180 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
181 /* hdmi deep color only implemented on DCE4+ */
182 if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
183 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
184 connector->name, bpc);
189 * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
190 * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
191 * 12 bpc is always supported on hdmi deep color sinks, as this is
192 * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
195 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
196 connector->name, bpc);
200 /* Any defined maximum tmds clock limit we must not exceed? */
201 if (connector->display_info.max_tmds_clock > 0) {
202 /* mode_clock is clock in kHz for mode to be modeset on this connector */
203 mode_clock = radeon_connector->pixelclock_for_modeset;
205 /* Maximum allowable input clock in kHz */
206 max_tmds_clock = connector->display_info.max_tmds_clock;
208 DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
209 connector->name, mode_clock, max_tmds_clock);
211 /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
212 if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
213 if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
214 (mode_clock * 5/4 <= max_tmds_clock))
219 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
220 connector->name, bpc);
223 if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
225 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
226 connector->name, bpc);
230 /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
231 DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
237 if ((radeon_deep_color == 0) && (bpc > 8)) {
238 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
243 DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
244 connector->name, connector->display_info.bpc, bpc);
250 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
252 struct drm_device *dev = connector->dev;
253 struct radeon_device *rdev = dev->dev_private;
254 struct drm_encoder *best_encoder = NULL;
255 struct drm_encoder *encoder = NULL;
256 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
260 best_encoder = connector_funcs->best_encoder(connector);
262 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
263 if (connector->encoder_ids[i] == 0)
266 encoder = drm_encoder_find(connector->dev, NULL,
267 connector->encoder_ids[i]);
271 if ((encoder == best_encoder) && (status == connector_status_connected))
276 if (rdev->is_atom_bios)
277 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
279 radeon_combios_connected_scratch_regs(connector, encoder, connected);
284 static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
286 struct drm_encoder *encoder;
289 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
290 if (connector->encoder_ids[i] == 0)
293 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
297 if (encoder->encoder_type == encoder_type)
303 struct edid *radeon_connector_edid(struct drm_connector *connector)
305 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
306 struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
308 if (radeon_connector->edid) {
309 return radeon_connector->edid;
310 } else if (edid_blob) {
311 struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
313 radeon_connector->edid = edid;
315 return radeon_connector->edid;
318 static void radeon_connector_get_edid(struct drm_connector *connector)
320 struct drm_device *dev = connector->dev;
321 struct radeon_device *rdev = dev->dev_private;
322 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
324 if (radeon_connector->edid)
327 /* on hw with routers, select right port */
328 if (radeon_connector->router.ddc_valid)
329 radeon_router_select_ddc_port(radeon_connector);
331 if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
332 ENCODER_OBJECT_ID_NONE) &&
333 radeon_connector->ddc_bus->has_aux) {
334 radeon_connector->edid = drm_get_edid(connector,
335 &radeon_connector->ddc_bus->aux.ddc);
336 } else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
337 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
338 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
340 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
341 dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
342 radeon_connector->ddc_bus->has_aux)
343 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
344 &radeon_connector->ddc_bus->aux.ddc);
345 else if (radeon_connector->ddc_bus)
346 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
347 &radeon_connector->ddc_bus->adapter);
348 } else if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC &&
349 connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
350 radeon_connector->ddc_bus) {
351 radeon_connector->edid = drm_get_edid_switcheroo(&radeon_connector->base,
352 &radeon_connector->ddc_bus->adapter);
353 } else if (radeon_connector->ddc_bus) {
354 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
355 &radeon_connector->ddc_bus->adapter);
358 if (!radeon_connector->edid) {
359 /* don't fetch the edid from the vbios if ddc fails and runpm is
360 * enabled so we report disconnected.
362 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
365 if (rdev->is_atom_bios) {
366 /* some laptops provide a hardcoded edid in rom for LCDs */
367 if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
368 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
369 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
371 /* some servers provide a hardcoded edid in rom for KVMs */
372 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
377 static void radeon_connector_free_edid(struct drm_connector *connector)
379 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
381 if (radeon_connector->edid) {
382 kfree(radeon_connector->edid);
383 radeon_connector->edid = NULL;
387 static int radeon_ddc_get_modes(struct drm_connector *connector)
389 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
392 if (radeon_connector->edid) {
393 drm_mode_connector_update_edid_property(connector, radeon_connector->edid);
394 ret = drm_add_edid_modes(connector, radeon_connector->edid);
395 drm_edid_to_eld(connector, radeon_connector->edid);
398 drm_mode_connector_update_edid_property(connector, NULL);
402 static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
404 int enc_id = connector->encoder_ids[0];
405 /* pick the encoder ids */
407 return drm_encoder_find(connector->dev, NULL, enc_id);
411 static void radeon_get_native_mode(struct drm_connector *connector)
413 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
414 struct radeon_encoder *radeon_encoder;
419 radeon_encoder = to_radeon_encoder(encoder);
421 if (!list_empty(&connector->probed_modes)) {
422 struct drm_display_mode *preferred_mode =
423 list_first_entry(&connector->probed_modes,
424 struct drm_display_mode, head);
426 radeon_encoder->native_mode = *preferred_mode;
428 radeon_encoder->native_mode.clock = 0;
433 * radeon_connector_analog_encoder_conflict_solve
434 * - search for other connectors sharing this encoder
435 * if priority is true, then set them disconnected if this is connected
436 * if priority is false, set us disconnected if they are connected
438 static enum drm_connector_status
439 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
440 struct drm_encoder *encoder,
441 enum drm_connector_status current_status,
444 struct drm_device *dev = connector->dev;
445 struct drm_connector *conflict;
446 struct radeon_connector *radeon_conflict;
449 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
450 if (conflict == connector)
453 radeon_conflict = to_radeon_connector(conflict);
454 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
455 if (conflict->encoder_ids[i] == 0)
458 /* if the IDs match */
459 if (conflict->encoder_ids[i] == encoder->base.id) {
460 if (conflict->status != connector_status_connected)
463 if (radeon_conflict->use_digital)
466 if (priority == true) {
467 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
469 DRM_DEBUG_KMS("in favor of %s\n",
471 conflict->status = connector_status_disconnected;
472 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
474 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
476 DRM_DEBUG_KMS("in favor of %s\n",
478 current_status = connector_status_disconnected;
484 return current_status;
488 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
490 struct drm_device *dev = encoder->dev;
491 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
492 struct drm_display_mode *mode = NULL;
493 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
495 if (native_mode->hdisplay != 0 &&
496 native_mode->vdisplay != 0 &&
497 native_mode->clock != 0) {
498 mode = drm_mode_duplicate(dev, native_mode);
499 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
500 drm_mode_set_name(mode);
502 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
503 } else if (native_mode->hdisplay != 0 &&
504 native_mode->vdisplay != 0) {
505 /* mac laptops without an edid */
506 /* Note that this is not necessarily the exact panel mode,
507 * but an approximation based on the cvt formula. For these
508 * systems we should ideally read the mode info out of the
509 * registers or add a mode table, but this works and is much
512 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
513 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
514 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
519 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
521 struct drm_device *dev = encoder->dev;
522 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
523 struct drm_display_mode *mode = NULL;
524 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
529 } common_modes[17] = {
549 for (i = 0; i < 17; i++) {
550 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
551 if (common_modes[i].w > 1024 ||
552 common_modes[i].h > 768)
555 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
556 if (common_modes[i].w > native_mode->hdisplay ||
557 common_modes[i].h > native_mode->vdisplay ||
558 (common_modes[i].w == native_mode->hdisplay &&
559 common_modes[i].h == native_mode->vdisplay))
562 if (common_modes[i].w < 320 || common_modes[i].h < 200)
565 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
566 drm_mode_probed_add(connector, mode);
570 static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
573 struct drm_device *dev = connector->dev;
574 struct radeon_device *rdev = dev->dev_private;
575 struct drm_encoder *encoder;
576 struct radeon_encoder *radeon_encoder;
578 if (property == rdev->mode_info.coherent_mode_property) {
579 struct radeon_encoder_atom_dig *dig;
580 bool new_coherent_mode;
582 /* need to find digital encoder on connector */
583 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
587 radeon_encoder = to_radeon_encoder(encoder);
589 if (!radeon_encoder->enc_priv)
592 dig = radeon_encoder->enc_priv;
593 new_coherent_mode = val ? true : false;
594 if (dig->coherent_mode != new_coherent_mode) {
595 dig->coherent_mode = new_coherent_mode;
596 radeon_property_change_mode(&radeon_encoder->base);
600 if (property == rdev->mode_info.audio_property) {
601 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
602 /* need to find digital encoder on connector */
603 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
607 radeon_encoder = to_radeon_encoder(encoder);
609 if (radeon_connector->audio != val) {
610 radeon_connector->audio = val;
611 radeon_property_change_mode(&radeon_encoder->base);
615 if (property == rdev->mode_info.dither_property) {
616 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
617 /* need to find digital encoder on connector */
618 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
622 radeon_encoder = to_radeon_encoder(encoder);
624 if (radeon_connector->dither != val) {
625 radeon_connector->dither = val;
626 radeon_property_change_mode(&radeon_encoder->base);
630 if (property == rdev->mode_info.underscan_property) {
631 /* need to find digital encoder on connector */
632 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
636 radeon_encoder = to_radeon_encoder(encoder);
638 if (radeon_encoder->underscan_type != val) {
639 radeon_encoder->underscan_type = val;
640 radeon_property_change_mode(&radeon_encoder->base);
644 if (property == rdev->mode_info.underscan_hborder_property) {
645 /* need to find digital encoder on connector */
646 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
650 radeon_encoder = to_radeon_encoder(encoder);
652 if (radeon_encoder->underscan_hborder != val) {
653 radeon_encoder->underscan_hborder = val;
654 radeon_property_change_mode(&radeon_encoder->base);
658 if (property == rdev->mode_info.underscan_vborder_property) {
659 /* need to find digital encoder on connector */
660 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
664 radeon_encoder = to_radeon_encoder(encoder);
666 if (radeon_encoder->underscan_vborder != val) {
667 radeon_encoder->underscan_vborder = val;
668 radeon_property_change_mode(&radeon_encoder->base);
672 if (property == rdev->mode_info.tv_std_property) {
673 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
675 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
681 radeon_encoder = to_radeon_encoder(encoder);
682 if (!radeon_encoder->enc_priv)
684 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
685 struct radeon_encoder_atom_dac *dac_int;
686 dac_int = radeon_encoder->enc_priv;
687 dac_int->tv_std = val;
689 struct radeon_encoder_tv_dac *dac_int;
690 dac_int = radeon_encoder->enc_priv;
691 dac_int->tv_std = val;
693 radeon_property_change_mode(&radeon_encoder->base);
696 if (property == rdev->mode_info.load_detect_property) {
697 struct radeon_connector *radeon_connector =
698 to_radeon_connector(connector);
701 radeon_connector->dac_load_detect = false;
703 radeon_connector->dac_load_detect = true;
706 if (property == rdev->mode_info.tmds_pll_property) {
707 struct radeon_encoder_int_tmds *tmds = NULL;
709 /* need to find digital encoder on connector */
710 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
714 radeon_encoder = to_radeon_encoder(encoder);
716 tmds = radeon_encoder->enc_priv;
721 if (rdev->is_atom_bios)
722 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
724 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
726 if (val == 1 || ret == false) {
727 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
729 radeon_property_change_mode(&radeon_encoder->base);
732 if (property == dev->mode_config.scaling_mode_property) {
733 enum radeon_rmx_type rmx_type;
735 if (connector->encoder)
736 radeon_encoder = to_radeon_encoder(connector->encoder);
738 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
739 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
744 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
745 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
746 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
747 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
749 if (radeon_encoder->rmx_type == rmx_type)
752 if ((rmx_type != DRM_MODE_SCALE_NONE) &&
753 (radeon_encoder->native_mode.clock == 0))
756 radeon_encoder->rmx_type = rmx_type;
758 radeon_property_change_mode(&radeon_encoder->base);
761 if (property == rdev->mode_info.output_csc_property) {
762 if (connector->encoder)
763 radeon_encoder = to_radeon_encoder(connector->encoder);
765 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
766 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
769 if (radeon_encoder->output_csc == val)
772 radeon_encoder->output_csc = val;
774 if (connector->encoder->crtc) {
775 struct drm_crtc *crtc = connector->encoder->crtc;
776 struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
778 radeon_crtc->output_csc = radeon_encoder->output_csc;
781 * Our .gamma_set assumes the .gamma_store has been
782 * prefilled and don't care about its arguments.
784 crtc->funcs->gamma_set(crtc, NULL, NULL, NULL, 0, NULL);
791 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
792 struct drm_connector *connector)
794 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
795 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
796 struct drm_display_mode *t, *mode;
798 /* If the EDID preferred mode doesn't match the native mode, use it */
799 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
800 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
801 if (mode->hdisplay != native_mode->hdisplay ||
802 mode->vdisplay != native_mode->vdisplay)
803 memcpy(native_mode, mode, sizeof(*mode));
807 /* Try to get native mode details from EDID if necessary */
808 if (!native_mode->clock) {
809 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
810 if (mode->hdisplay == native_mode->hdisplay &&
811 mode->vdisplay == native_mode->vdisplay) {
812 *native_mode = *mode;
813 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
814 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
820 if (!native_mode->clock) {
821 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
822 radeon_encoder->rmx_type = RMX_OFF;
826 static int radeon_lvds_get_modes(struct drm_connector *connector)
828 struct drm_encoder *encoder;
830 struct drm_display_mode *mode;
832 radeon_connector_get_edid(connector);
833 ret = radeon_ddc_get_modes(connector);
835 encoder = radeon_best_single_encoder(connector);
837 radeon_fixup_lvds_native_mode(encoder, connector);
838 /* add scaled modes */
839 radeon_add_common_modes(encoder, connector);
844 encoder = radeon_best_single_encoder(connector);
848 /* we have no EDID modes */
849 mode = radeon_fp_native_mode(encoder);
852 drm_mode_probed_add(connector, mode);
853 /* add the width/height from vbios tables if available */
854 connector->display_info.width_mm = mode->width_mm;
855 connector->display_info.height_mm = mode->height_mm;
856 /* add scaled modes */
857 radeon_add_common_modes(encoder, connector);
863 static int radeon_lvds_mode_valid(struct drm_connector *connector,
864 struct drm_display_mode *mode)
866 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
868 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
872 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
873 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
875 /* AVIVO hardware supports downscaling modes larger than the panel
876 * to the panel size, but I'm not sure this is desirable.
878 if ((mode->hdisplay > native_mode->hdisplay) ||
879 (mode->vdisplay > native_mode->vdisplay))
882 /* if scaling is disabled, block non-native modes */
883 if (radeon_encoder->rmx_type == RMX_OFF) {
884 if ((mode->hdisplay != native_mode->hdisplay) ||
885 (mode->vdisplay != native_mode->vdisplay))
893 static enum drm_connector_status
894 radeon_lvds_detect(struct drm_connector *connector, bool force)
896 struct drm_device *dev = connector->dev;
897 struct radeon_device *rdev = dev->dev_private;
898 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
899 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
900 enum drm_connector_status ret = connector_status_disconnected;
903 r = pm_runtime_get_sync(connector->dev->dev);
905 return connector_status_disconnected;
908 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
909 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
911 /* check if panel is valid */
912 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
913 ret = connector_status_connected;
914 /* don't fetch the edid from the vbios if ddc fails and runpm is
915 * enabled so we report disconnected.
917 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
918 ret = connector_status_disconnected;
921 /* check for edid as well */
922 radeon_connector_get_edid(connector);
923 if (radeon_connector->edid)
924 ret = connector_status_connected;
925 /* check acpi lid status ??? */
927 radeon_connector_update_scratch_regs(connector, ret);
928 pm_runtime_mark_last_busy(connector->dev->dev);
929 pm_runtime_put_autosuspend(connector->dev->dev);
933 static void radeon_connector_unregister(struct drm_connector *connector)
935 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
937 if (radeon_connector->ddc_bus && radeon_connector->ddc_bus->has_aux) {
938 drm_dp_aux_unregister(&radeon_connector->ddc_bus->aux);
939 radeon_connector->ddc_bus->has_aux = false;
943 static void radeon_connector_destroy(struct drm_connector *connector)
945 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
947 radeon_connector_free_edid(connector);
948 kfree(radeon_connector->con_priv);
949 drm_connector_unregister(connector);
950 drm_connector_cleanup(connector);
954 static int radeon_lvds_set_property(struct drm_connector *connector,
955 struct drm_property *property,
958 struct drm_device *dev = connector->dev;
959 struct radeon_encoder *radeon_encoder;
960 enum radeon_rmx_type rmx_type;
963 if (property != dev->mode_config.scaling_mode_property)
966 if (connector->encoder)
967 radeon_encoder = to_radeon_encoder(connector->encoder);
969 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
970 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
974 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
975 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
976 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
978 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
980 if (radeon_encoder->rmx_type == rmx_type)
983 radeon_encoder->rmx_type = rmx_type;
985 radeon_property_change_mode(&radeon_encoder->base);
990 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
991 .get_modes = radeon_lvds_get_modes,
992 .mode_valid = radeon_lvds_mode_valid,
993 .best_encoder = radeon_best_single_encoder,
996 static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
997 .dpms = drm_helper_connector_dpms,
998 .detect = radeon_lvds_detect,
999 .fill_modes = drm_helper_probe_single_connector_modes,
1000 .early_unregister = radeon_connector_unregister,
1001 .destroy = radeon_connector_destroy,
1002 .set_property = radeon_lvds_set_property,
1005 static int radeon_vga_get_modes(struct drm_connector *connector)
1009 radeon_connector_get_edid(connector);
1010 ret = radeon_ddc_get_modes(connector);
1012 radeon_get_native_mode(connector);
1017 static int radeon_vga_mode_valid(struct drm_connector *connector,
1018 struct drm_display_mode *mode)
1020 struct drm_device *dev = connector->dev;
1021 struct radeon_device *rdev = dev->dev_private;
1023 /* XXX check mode bandwidth */
1025 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1026 return MODE_CLOCK_HIGH;
1031 static enum drm_connector_status
1032 radeon_vga_detect(struct drm_connector *connector, bool force)
1034 struct drm_device *dev = connector->dev;
1035 struct radeon_device *rdev = dev->dev_private;
1036 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1037 struct drm_encoder *encoder;
1038 const struct drm_encoder_helper_funcs *encoder_funcs;
1040 enum drm_connector_status ret = connector_status_disconnected;
1043 r = pm_runtime_get_sync(connector->dev->dev);
1045 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 pm_runtime_mark_last_busy(connector->dev->dev);
1113 pm_runtime_put_autosuspend(connector->dev->dev);
1118 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
1119 .get_modes = radeon_vga_get_modes,
1120 .mode_valid = radeon_vga_mode_valid,
1121 .best_encoder = radeon_best_single_encoder,
1124 static const struct drm_connector_funcs radeon_vga_connector_funcs = {
1125 .dpms = drm_helper_connector_dpms,
1126 .detect = radeon_vga_detect,
1127 .fill_modes = drm_helper_probe_single_connector_modes,
1128 .early_unregister = radeon_connector_unregister,
1129 .destroy = radeon_connector_destroy,
1130 .set_property = radeon_connector_set_property,
1133 static int radeon_tv_get_modes(struct drm_connector *connector)
1135 struct drm_device *dev = connector->dev;
1136 struct radeon_device *rdev = dev->dev_private;
1137 struct drm_display_mode *tv_mode;
1138 struct drm_encoder *encoder;
1140 encoder = radeon_best_single_encoder(connector);
1144 /* avivo chips can scale any mode */
1145 if (rdev->family >= CHIP_RS600)
1146 /* add scaled modes */
1147 radeon_add_common_modes(encoder, connector);
1149 /* only 800x600 is supported right now on pre-avivo chips */
1150 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1151 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
1152 drm_mode_probed_add(connector, tv_mode);
1157 static int radeon_tv_mode_valid(struct drm_connector *connector,
1158 struct drm_display_mode *mode)
1160 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
1161 return MODE_CLOCK_RANGE;
1165 static enum drm_connector_status
1166 radeon_tv_detect(struct drm_connector *connector, bool force)
1168 struct drm_encoder *encoder;
1169 const struct drm_encoder_helper_funcs *encoder_funcs;
1170 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1171 enum drm_connector_status ret = connector_status_disconnected;
1174 if (!radeon_connector->dac_load_detect)
1177 r = pm_runtime_get_sync(connector->dev->dev);
1179 return connector_status_disconnected;
1181 encoder = radeon_best_single_encoder(connector);
1183 ret = connector_status_disconnected;
1185 encoder_funcs = encoder->helper_private;
1186 ret = encoder_funcs->detect(encoder, connector);
1188 if (ret == connector_status_connected)
1189 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
1190 radeon_connector_update_scratch_regs(connector, ret);
1191 pm_runtime_mark_last_busy(connector->dev->dev);
1192 pm_runtime_put_autosuspend(connector->dev->dev);
1196 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1197 .get_modes = radeon_tv_get_modes,
1198 .mode_valid = radeon_tv_mode_valid,
1199 .best_encoder = radeon_best_single_encoder,
1202 static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1203 .dpms = drm_helper_connector_dpms,
1204 .detect = radeon_tv_detect,
1205 .fill_modes = drm_helper_probe_single_connector_modes,
1206 .early_unregister = radeon_connector_unregister,
1207 .destroy = radeon_connector_destroy,
1208 .set_property = radeon_connector_set_property,
1211 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
1213 struct drm_device *dev = connector->dev;
1214 struct radeon_device *rdev = dev->dev_private;
1215 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1216 enum drm_connector_status status;
1218 /* We only trust HPD on R600 and newer ASICS. */
1219 if (rdev->family >= CHIP_R600
1220 && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
1221 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
1222 status = connector_status_connected;
1224 status = connector_status_disconnected;
1225 if (connector->status == status)
1233 * DVI is complicated
1234 * Do a DDC probe, if DDC probe passes, get the full EDID so
1235 * we can do analog/digital monitor detection at this point.
1236 * If the monitor is an analog monitor or we got no DDC,
1237 * we need to find the DAC encoder object for this connector.
1238 * If we got no DDC, we do load detection on the DAC encoder object.
1239 * If we got analog DDC or load detection passes on the DAC encoder
1240 * we have to check if this analog encoder is shared with anyone else (TV)
1241 * if its shared we have to set the other connector to disconnected.
1243 static enum drm_connector_status
1244 radeon_dvi_detect(struct drm_connector *connector, bool force)
1246 struct drm_device *dev = connector->dev;
1247 struct radeon_device *rdev = dev->dev_private;
1248 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1249 struct drm_encoder *encoder = NULL;
1250 const struct drm_encoder_helper_funcs *encoder_funcs;
1252 enum drm_connector_status ret = connector_status_disconnected;
1253 bool dret = false, broken_edid = false;
1255 r = pm_runtime_get_sync(connector->dev->dev);
1257 return connector_status_disconnected;
1259 if (radeon_connector->detected_hpd_without_ddc) {
1261 radeon_connector->detected_hpd_without_ddc = false;
1264 if (!force && radeon_check_hpd_status_unchanged(connector)) {
1265 ret = connector->status;
1269 if (radeon_connector->ddc_bus) {
1270 dret = radeon_ddc_probe(radeon_connector, false);
1272 /* Sometimes the pins required for the DDC probe on DVI
1273 * connectors don't make contact at the same time that the ones
1274 * for HPD do. If the DDC probe fails even though we had an HPD
1275 * signal, try again later */
1276 if (!dret && !force &&
1277 connector->status != connector_status_connected) {
1278 DRM_DEBUG_KMS("hpd detected without ddc, retrying in 1 second\n");
1279 radeon_connector->detected_hpd_without_ddc = true;
1280 schedule_delayed_work(&rdev->hotplug_work,
1281 msecs_to_jiffies(1000));
1286 radeon_connector->detected_by_load = false;
1287 radeon_connector_free_edid(connector);
1288 radeon_connector_get_edid(connector);
1290 if (!radeon_connector->edid) {
1291 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1293 /* rs690 seems to have a problem with connectors not existing and always
1294 * return a block of 0's. If we see this just stop polling on this output */
1295 if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
1296 radeon_connector->base.null_edid_counter) {
1297 ret = connector_status_disconnected;
1298 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1300 radeon_connector->ddc_bus = NULL;
1302 ret = connector_status_connected;
1303 broken_edid = true; /* defer use_digital to later */
1306 radeon_connector->use_digital =
1307 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1309 /* some oems have boards with separate digital and analog connectors
1310 * with a shared ddc line (often vga + hdmi)
1312 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
1313 radeon_connector_free_edid(connector);
1314 ret = connector_status_disconnected;
1316 ret = connector_status_connected;
1318 /* This gets complicated. We have boards with VGA + HDMI with a
1319 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1320 * DDC line. The latter is more complex because with DVI<->HDMI adapters
1321 * you don't really know what's connected to which port as both are digital.
1323 if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1324 struct drm_connector *list_connector;
1325 struct radeon_connector *list_radeon_connector;
1326 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
1327 if (connector == list_connector)
1329 list_radeon_connector = to_radeon_connector(list_connector);
1330 if (list_radeon_connector->shared_ddc &&
1331 (list_radeon_connector->ddc_bus->rec.i2c_id ==
1332 radeon_connector->ddc_bus->rec.i2c_id)) {
1333 /* cases where both connectors are digital */
1334 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1335 /* hpd is our only option in this case */
1336 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1337 radeon_connector_free_edid(connector);
1338 ret = connector_status_disconnected;
1347 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1350 /* DVI-D and HDMI-A are digital only */
1351 if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1352 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1355 /* if we aren't forcing don't do destructive polling */
1357 /* only return the previous status if we last
1358 * detected a monitor via load.
1360 if (radeon_connector->detected_by_load)
1361 ret = connector->status;
1365 /* find analog encoder */
1366 if (radeon_connector->dac_load_detect) {
1367 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1368 if (connector->encoder_ids[i] == 0)
1371 encoder = drm_encoder_find(connector->dev, NULL,
1372 connector->encoder_ids[i]);
1376 if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1377 encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1380 encoder_funcs = encoder->helper_private;
1381 if (encoder_funcs->detect) {
1383 if (ret != connector_status_connected) {
1384 /* deal with analog monitors without DDC */
1385 ret = encoder_funcs->detect(encoder, connector);
1386 if (ret == connector_status_connected) {
1387 radeon_connector->use_digital = false;
1389 if (ret != connector_status_disconnected)
1390 radeon_connector->detected_by_load = true;
1393 enum drm_connector_status lret;
1394 /* assume digital unless load detected otherwise */
1395 radeon_connector->use_digital = true;
1396 lret = encoder_funcs->detect(encoder, connector);
1397 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
1398 if (lret == connector_status_connected)
1399 radeon_connector->use_digital = false;
1406 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1408 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1411 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1412 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1413 * by other means, assume the DFP is connected and use that EDID. In most
1414 * cases the DVI port is actually a virtual KVM port connected to the service
1418 if ((!rdev->is_atom_bios) &&
1419 (ret == connector_status_disconnected) &&
1420 rdev->mode_info.bios_hardcoded_edid_size) {
1421 radeon_connector->use_digital = true;
1422 ret = connector_status_connected;
1425 /* updated in get modes as well since we need to know if it's analog or digital */
1426 radeon_connector_update_scratch_regs(connector, ret);
1428 if ((radeon_audio != 0) && radeon_connector->use_digital) {
1429 const struct drm_connector_helper_funcs *connector_funcs =
1430 connector->helper_private;
1432 encoder = connector_funcs->best_encoder(connector);
1433 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
1434 radeon_connector_get_edid(connector);
1435 radeon_audio_detect(connector, encoder, ret);
1440 pm_runtime_mark_last_busy(connector->dev->dev);
1441 pm_runtime_put_autosuspend(connector->dev->dev);
1446 /* okay need to be smart in here about which encoder to pick */
1447 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1449 int enc_id = connector->encoder_ids[0];
1450 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1451 struct drm_encoder *encoder;
1453 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1454 if (connector->encoder_ids[i] == 0)
1457 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
1461 if (radeon_connector->use_digital == true) {
1462 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1465 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1466 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1471 /* see if we have a default encoder TODO */
1473 /* then check use digitial */
1474 /* pick the first one */
1476 return drm_encoder_find(connector->dev, NULL, enc_id);
1480 static void radeon_dvi_force(struct drm_connector *connector)
1482 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1483 if (connector->force == DRM_FORCE_ON)
1484 radeon_connector->use_digital = false;
1485 if (connector->force == DRM_FORCE_ON_DIGITAL)
1486 radeon_connector->use_digital = true;
1489 static int radeon_dvi_mode_valid(struct drm_connector *connector,
1490 struct drm_display_mode *mode)
1492 struct drm_device *dev = connector->dev;
1493 struct radeon_device *rdev = dev->dev_private;
1494 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1496 /* XXX check mode bandwidth */
1498 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1499 if (radeon_connector->use_digital &&
1500 (rdev->family == CHIP_RV100) &&
1501 (mode->clock > 135000))
1502 return MODE_CLOCK_HIGH;
1504 if (radeon_connector->use_digital && (mode->clock > 165000)) {
1505 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1506 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1507 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1509 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1510 /* HDMI 1.3+ supports max clock of 340 Mhz */
1511 if (mode->clock > 340000)
1512 return MODE_CLOCK_HIGH;
1516 return MODE_CLOCK_HIGH;
1520 /* check against the max pixel clock */
1521 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1522 return MODE_CLOCK_HIGH;
1527 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1528 .get_modes = radeon_vga_get_modes,
1529 .mode_valid = radeon_dvi_mode_valid,
1530 .best_encoder = radeon_dvi_encoder,
1533 static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1534 .dpms = drm_helper_connector_dpms,
1535 .detect = radeon_dvi_detect,
1536 .fill_modes = drm_helper_probe_single_connector_modes,
1537 .set_property = radeon_connector_set_property,
1538 .early_unregister = radeon_connector_unregister,
1539 .destroy = radeon_connector_destroy,
1540 .force = radeon_dvi_force,
1543 static int radeon_dp_get_modes(struct drm_connector *connector)
1545 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1546 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1547 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1550 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1551 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1552 struct drm_display_mode *mode;
1554 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1555 if (!radeon_dig_connector->edp_on)
1556 atombios_set_edp_panel_power(connector,
1557 ATOM_TRANSMITTER_ACTION_POWER_ON);
1558 radeon_connector_get_edid(connector);
1559 ret = radeon_ddc_get_modes(connector);
1560 if (!radeon_dig_connector->edp_on)
1561 atombios_set_edp_panel_power(connector,
1562 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1564 /* need to setup ddc on the bridge */
1565 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1566 ENCODER_OBJECT_ID_NONE) {
1568 radeon_atom_ext_encoder_setup_ddc(encoder);
1570 radeon_connector_get_edid(connector);
1571 ret = radeon_ddc_get_modes(connector);
1576 radeon_fixup_lvds_native_mode(encoder, connector);
1577 /* add scaled modes */
1578 radeon_add_common_modes(encoder, connector);
1586 /* we have no EDID modes */
1587 mode = radeon_fp_native_mode(encoder);
1590 drm_mode_probed_add(connector, mode);
1591 /* add the width/height from vbios tables if available */
1592 connector->display_info.width_mm = mode->width_mm;
1593 connector->display_info.height_mm = mode->height_mm;
1594 /* add scaled modes */
1595 radeon_add_common_modes(encoder, connector);
1598 /* need to setup ddc on the bridge */
1599 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1600 ENCODER_OBJECT_ID_NONE) {
1602 radeon_atom_ext_encoder_setup_ddc(encoder);
1604 radeon_connector_get_edid(connector);
1605 ret = radeon_ddc_get_modes(connector);
1607 radeon_get_native_mode(connector);
1613 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1615 struct drm_encoder *encoder;
1616 struct radeon_encoder *radeon_encoder;
1619 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1620 if (connector->encoder_ids[i] == 0)
1623 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
1627 radeon_encoder = to_radeon_encoder(encoder);
1629 switch (radeon_encoder->encoder_id) {
1630 case ENCODER_OBJECT_ID_TRAVIS:
1631 case ENCODER_OBJECT_ID_NUTMEG:
1632 return radeon_encoder->encoder_id;
1638 return ENCODER_OBJECT_ID_NONE;
1641 static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1643 struct drm_encoder *encoder;
1644 struct radeon_encoder *radeon_encoder;
1648 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1649 if (connector->encoder_ids[i] == 0)
1652 encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
1656 radeon_encoder = to_radeon_encoder(encoder);
1657 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1664 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1666 struct drm_device *dev = connector->dev;
1667 struct radeon_device *rdev = dev->dev_private;
1669 if (ASIC_IS_DCE5(rdev) &&
1670 (rdev->clock.default_dispclk >= 53900) &&
1671 radeon_connector_encoder_is_hbr2(connector)) {
1678 static enum drm_connector_status
1679 radeon_dp_detect(struct drm_connector *connector, bool force)
1681 struct drm_device *dev = connector->dev;
1682 struct radeon_device *rdev = dev->dev_private;
1683 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1684 enum drm_connector_status ret = connector_status_disconnected;
1685 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1686 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1689 if (radeon_dig_connector->is_mst)
1690 return connector_status_disconnected;
1692 r = pm_runtime_get_sync(connector->dev->dev);
1694 return connector_status_disconnected;
1696 if (!force && radeon_check_hpd_status_unchanged(connector)) {
1697 ret = connector->status;
1701 radeon_connector_free_edid(connector);
1703 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1704 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1706 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1707 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1709 /* check if panel is valid */
1710 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1711 ret = connector_status_connected;
1712 /* don't fetch the edid from the vbios if ddc fails and runpm is
1713 * enabled so we report disconnected.
1715 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
1716 ret = connector_status_disconnected;
1718 /* eDP is always DP */
1719 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1720 if (!radeon_dig_connector->edp_on)
1721 atombios_set_edp_panel_power(connector,
1722 ATOM_TRANSMITTER_ACTION_POWER_ON);
1723 if (radeon_dp_getdpcd(radeon_connector))
1724 ret = connector_status_connected;
1725 if (!radeon_dig_connector->edp_on)
1726 atombios_set_edp_panel_power(connector,
1727 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1728 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1729 ENCODER_OBJECT_ID_NONE) {
1730 /* DP bridges are always DP */
1731 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1732 /* get the DPCD from the bridge */
1733 radeon_dp_getdpcd(radeon_connector);
1736 /* setup ddc on the bridge */
1737 radeon_atom_ext_encoder_setup_ddc(encoder);
1738 /* bridge chips are always aux */
1739 if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
1740 ret = connector_status_connected;
1741 else if (radeon_connector->dac_load_detect) { /* try load detection */
1742 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1743 ret = encoder_funcs->detect(encoder, connector);
1747 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1748 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1749 ret = connector_status_connected;
1750 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1751 radeon_dp_getdpcd(radeon_connector);
1752 r = radeon_dp_mst_probe(radeon_connector);
1754 ret = connector_status_disconnected;
1757 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1758 if (radeon_dp_getdpcd(radeon_connector)) {
1759 r = radeon_dp_mst_probe(radeon_connector);
1761 ret = connector_status_disconnected;
1763 ret = connector_status_connected;
1766 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1767 if (radeon_ddc_probe(radeon_connector, false))
1768 ret = connector_status_connected;
1773 radeon_connector_update_scratch_regs(connector, ret);
1775 if ((radeon_audio != 0) && encoder) {
1776 radeon_connector_get_edid(connector);
1777 radeon_audio_detect(connector, encoder, ret);
1781 pm_runtime_mark_last_busy(connector->dev->dev);
1782 pm_runtime_put_autosuspend(connector->dev->dev);
1787 static int radeon_dp_mode_valid(struct drm_connector *connector,
1788 struct drm_display_mode *mode)
1790 struct drm_device *dev = connector->dev;
1791 struct radeon_device *rdev = dev->dev_private;
1792 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1793 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1795 /* XXX check mode bandwidth */
1797 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1798 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1799 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1801 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1805 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1806 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1808 /* AVIVO hardware supports downscaling modes larger than the panel
1809 * to the panel size, but I'm not sure this is desirable.
1811 if ((mode->hdisplay > native_mode->hdisplay) ||
1812 (mode->vdisplay > native_mode->vdisplay))
1815 /* if scaling is disabled, block non-native modes */
1816 if (radeon_encoder->rmx_type == RMX_OFF) {
1817 if ((mode->hdisplay != native_mode->hdisplay) ||
1818 (mode->vdisplay != native_mode->vdisplay))
1823 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1824 (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1825 return radeon_dp_mode_valid_helper(connector, mode);
1827 if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1828 /* HDMI 1.3+ supports max clock of 340 Mhz */
1829 if (mode->clock > 340000)
1830 return MODE_CLOCK_HIGH;
1832 if (mode->clock > 165000)
1833 return MODE_CLOCK_HIGH;
1841 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1842 .get_modes = radeon_dp_get_modes,
1843 .mode_valid = radeon_dp_mode_valid,
1844 .best_encoder = radeon_dvi_encoder,
1847 static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1848 .dpms = drm_helper_connector_dpms,
1849 .detect = radeon_dp_detect,
1850 .fill_modes = drm_helper_probe_single_connector_modes,
1851 .set_property = radeon_connector_set_property,
1852 .early_unregister = radeon_connector_unregister,
1853 .destroy = radeon_connector_destroy,
1854 .force = radeon_dvi_force,
1857 static const struct drm_connector_funcs radeon_edp_connector_funcs = {
1858 .dpms = drm_helper_connector_dpms,
1859 .detect = radeon_dp_detect,
1860 .fill_modes = drm_helper_probe_single_connector_modes,
1861 .set_property = radeon_lvds_set_property,
1862 .early_unregister = radeon_connector_unregister,
1863 .destroy = radeon_connector_destroy,
1864 .force = radeon_dvi_force,
1867 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
1868 .dpms = drm_helper_connector_dpms,
1869 .detect = radeon_dp_detect,
1870 .fill_modes = drm_helper_probe_single_connector_modes,
1871 .set_property = radeon_lvds_set_property,
1872 .early_unregister = radeon_connector_unregister,
1873 .destroy = radeon_connector_destroy,
1874 .force = radeon_dvi_force,
1878 radeon_add_atom_connector(struct drm_device *dev,
1879 uint32_t connector_id,
1880 uint32_t supported_device,
1882 struct radeon_i2c_bus_rec *i2c_bus,
1883 uint32_t igp_lane_info,
1884 uint16_t connector_object_id,
1885 struct radeon_hpd *hpd,
1886 struct radeon_router *router)
1888 struct radeon_device *rdev = dev->dev_private;
1889 struct drm_connector *connector;
1890 struct radeon_connector *radeon_connector;
1891 struct radeon_connector_atom_dig *radeon_dig_connector;
1892 struct drm_encoder *encoder;
1893 struct radeon_encoder *radeon_encoder;
1894 uint32_t subpixel_order = SubPixelNone;
1895 bool shared_ddc = false;
1896 bool is_dp_bridge = false;
1897 bool has_aux = false;
1899 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1902 /* if the user selected tv=0 don't try and add the connector */
1903 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1904 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1905 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1909 /* see if we already added it */
1910 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1911 radeon_connector = to_radeon_connector(connector);
1912 if (radeon_connector->connector_id == connector_id) {
1913 radeon_connector->devices |= supported_device;
1916 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1917 if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1918 radeon_connector->shared_ddc = true;
1921 if (radeon_connector->router_bus && router->ddc_valid &&
1922 (radeon_connector->router.router_id == router->router_id)) {
1923 radeon_connector->shared_ddc = false;
1929 /* check if it's a dp bridge */
1930 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1931 radeon_encoder = to_radeon_encoder(encoder);
1932 if (radeon_encoder->devices & supported_device) {
1933 switch (radeon_encoder->encoder_id) {
1934 case ENCODER_OBJECT_ID_TRAVIS:
1935 case ENCODER_OBJECT_ID_NUTMEG:
1936 is_dp_bridge = true;
1944 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1945 if (!radeon_connector)
1948 connector = &radeon_connector->base;
1950 radeon_connector->connector_id = connector_id;
1951 radeon_connector->devices = supported_device;
1952 radeon_connector->shared_ddc = shared_ddc;
1953 radeon_connector->connector_object_id = connector_object_id;
1954 radeon_connector->hpd = *hpd;
1956 radeon_connector->router = *router;
1957 if (router->ddc_valid || router->cd_valid) {
1958 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1959 if (!radeon_connector->router_bus)
1960 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1964 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1965 if (!radeon_dig_connector)
1967 radeon_dig_connector->igp_lane_info = igp_lane_info;
1968 radeon_connector->con_priv = radeon_dig_connector;
1969 if (i2c_bus->valid) {
1970 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1971 if (radeon_connector->ddc_bus)
1974 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1976 switch (connector_type) {
1977 case DRM_MODE_CONNECTOR_VGA:
1978 case DRM_MODE_CONNECTOR_DVIA:
1980 drm_connector_init(dev, &radeon_connector->base,
1981 &radeon_dp_connector_funcs, connector_type);
1982 drm_connector_helper_add(&radeon_connector->base,
1983 &radeon_dp_connector_helper_funcs);
1984 connector->interlace_allowed = true;
1985 connector->doublescan_allowed = true;
1986 radeon_connector->dac_load_detect = true;
1987 drm_object_attach_property(&radeon_connector->base.base,
1988 rdev->mode_info.load_detect_property,
1990 drm_object_attach_property(&radeon_connector->base.base,
1991 dev->mode_config.scaling_mode_property,
1992 DRM_MODE_SCALE_NONE);
1993 if (ASIC_IS_DCE5(rdev))
1994 drm_object_attach_property(&radeon_connector->base.base,
1995 rdev->mode_info.output_csc_property,
1996 RADEON_OUTPUT_CSC_BYPASS);
1998 case DRM_MODE_CONNECTOR_DVII:
1999 case DRM_MODE_CONNECTOR_DVID:
2000 case DRM_MODE_CONNECTOR_HDMIA:
2001 case DRM_MODE_CONNECTOR_HDMIB:
2002 case DRM_MODE_CONNECTOR_DisplayPort:
2003 drm_connector_init(dev, &radeon_connector->base,
2004 &radeon_dp_connector_funcs, connector_type);
2005 drm_connector_helper_add(&radeon_connector->base,
2006 &radeon_dp_connector_helper_funcs);
2007 drm_object_attach_property(&radeon_connector->base.base,
2008 rdev->mode_info.underscan_property,
2010 drm_object_attach_property(&radeon_connector->base.base,
2011 rdev->mode_info.underscan_hborder_property,
2013 drm_object_attach_property(&radeon_connector->base.base,
2014 rdev->mode_info.underscan_vborder_property,
2017 drm_object_attach_property(&radeon_connector->base.base,
2018 dev->mode_config.scaling_mode_property,
2019 DRM_MODE_SCALE_NONE);
2021 drm_object_attach_property(&radeon_connector->base.base,
2022 rdev->mode_info.dither_property,
2023 RADEON_FMT_DITHER_DISABLE);
2025 if (radeon_audio != 0) {
2026 drm_object_attach_property(&radeon_connector->base.base,
2027 rdev->mode_info.audio_property,
2029 radeon_connector->audio = RADEON_AUDIO_AUTO;
2031 if (ASIC_IS_DCE5(rdev))
2032 drm_object_attach_property(&radeon_connector->base.base,
2033 rdev->mode_info.output_csc_property,
2034 RADEON_OUTPUT_CSC_BYPASS);
2036 subpixel_order = SubPixelHorizontalRGB;
2037 connector->interlace_allowed = true;
2038 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2039 connector->doublescan_allowed = true;
2041 connector->doublescan_allowed = false;
2042 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2043 radeon_connector->dac_load_detect = true;
2044 drm_object_attach_property(&radeon_connector->base.base,
2045 rdev->mode_info.load_detect_property,
2049 case DRM_MODE_CONNECTOR_LVDS:
2050 case DRM_MODE_CONNECTOR_eDP:
2051 drm_connector_init(dev, &radeon_connector->base,
2052 &radeon_lvds_bridge_connector_funcs, connector_type);
2053 drm_connector_helper_add(&radeon_connector->base,
2054 &radeon_dp_connector_helper_funcs);
2055 drm_object_attach_property(&radeon_connector->base.base,
2056 dev->mode_config.scaling_mode_property,
2057 DRM_MODE_SCALE_FULLSCREEN);
2058 subpixel_order = SubPixelHorizontalRGB;
2059 connector->interlace_allowed = false;
2060 connector->doublescan_allowed = false;
2064 switch (connector_type) {
2065 case DRM_MODE_CONNECTOR_VGA:
2066 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2067 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2068 if (i2c_bus->valid) {
2069 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2070 if (!radeon_connector->ddc_bus)
2071 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2073 radeon_connector->dac_load_detect = true;
2074 drm_object_attach_property(&radeon_connector->base.base,
2075 rdev->mode_info.load_detect_property,
2077 if (ASIC_IS_AVIVO(rdev))
2078 drm_object_attach_property(&radeon_connector->base.base,
2079 dev->mode_config.scaling_mode_property,
2080 DRM_MODE_SCALE_NONE);
2081 if (ASIC_IS_DCE5(rdev))
2082 drm_object_attach_property(&radeon_connector->base.base,
2083 rdev->mode_info.output_csc_property,
2084 RADEON_OUTPUT_CSC_BYPASS);
2085 /* no HPD on analog connectors */
2086 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2087 connector->interlace_allowed = true;
2088 connector->doublescan_allowed = true;
2090 case DRM_MODE_CONNECTOR_DVIA:
2091 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2092 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2093 if (i2c_bus->valid) {
2094 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2095 if (!radeon_connector->ddc_bus)
2096 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2098 radeon_connector->dac_load_detect = true;
2099 drm_object_attach_property(&radeon_connector->base.base,
2100 rdev->mode_info.load_detect_property,
2102 if (ASIC_IS_AVIVO(rdev))
2103 drm_object_attach_property(&radeon_connector->base.base,
2104 dev->mode_config.scaling_mode_property,
2105 DRM_MODE_SCALE_NONE);
2106 if (ASIC_IS_DCE5(rdev))
2107 drm_object_attach_property(&radeon_connector->base.base,
2108 rdev->mode_info.output_csc_property,
2109 RADEON_OUTPUT_CSC_BYPASS);
2110 /* no HPD on analog connectors */
2111 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2112 connector->interlace_allowed = true;
2113 connector->doublescan_allowed = true;
2115 case DRM_MODE_CONNECTOR_DVII:
2116 case DRM_MODE_CONNECTOR_DVID:
2117 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2118 if (!radeon_dig_connector)
2120 radeon_dig_connector->igp_lane_info = igp_lane_info;
2121 radeon_connector->con_priv = radeon_dig_connector;
2122 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2123 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2124 if (i2c_bus->valid) {
2125 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2126 if (!radeon_connector->ddc_bus)
2127 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2129 subpixel_order = SubPixelHorizontalRGB;
2130 drm_object_attach_property(&radeon_connector->base.base,
2131 rdev->mode_info.coherent_mode_property,
2133 if (ASIC_IS_AVIVO(rdev)) {
2134 drm_object_attach_property(&radeon_connector->base.base,
2135 rdev->mode_info.underscan_property,
2137 drm_object_attach_property(&radeon_connector->base.base,
2138 rdev->mode_info.underscan_hborder_property,
2140 drm_object_attach_property(&radeon_connector->base.base,
2141 rdev->mode_info.underscan_vborder_property,
2143 drm_object_attach_property(&radeon_connector->base.base,
2144 rdev->mode_info.dither_property,
2145 RADEON_FMT_DITHER_DISABLE);
2146 drm_object_attach_property(&radeon_connector->base.base,
2147 dev->mode_config.scaling_mode_property,
2148 DRM_MODE_SCALE_NONE);
2150 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2151 drm_object_attach_property(&radeon_connector->base.base,
2152 rdev->mode_info.audio_property,
2154 radeon_connector->audio = RADEON_AUDIO_AUTO;
2156 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2157 radeon_connector->dac_load_detect = true;
2158 drm_object_attach_property(&radeon_connector->base.base,
2159 rdev->mode_info.load_detect_property,
2162 if (ASIC_IS_DCE5(rdev))
2163 drm_object_attach_property(&radeon_connector->base.base,
2164 rdev->mode_info.output_csc_property,
2165 RADEON_OUTPUT_CSC_BYPASS);
2166 connector->interlace_allowed = true;
2167 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2168 connector->doublescan_allowed = true;
2170 connector->doublescan_allowed = false;
2172 case DRM_MODE_CONNECTOR_HDMIA:
2173 case DRM_MODE_CONNECTOR_HDMIB:
2174 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2175 if (!radeon_dig_connector)
2177 radeon_dig_connector->igp_lane_info = igp_lane_info;
2178 radeon_connector->con_priv = radeon_dig_connector;
2179 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2180 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2181 if (i2c_bus->valid) {
2182 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2183 if (!radeon_connector->ddc_bus)
2184 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2186 drm_object_attach_property(&radeon_connector->base.base,
2187 rdev->mode_info.coherent_mode_property,
2189 if (ASIC_IS_AVIVO(rdev)) {
2190 drm_object_attach_property(&radeon_connector->base.base,
2191 rdev->mode_info.underscan_property,
2193 drm_object_attach_property(&radeon_connector->base.base,
2194 rdev->mode_info.underscan_hborder_property,
2196 drm_object_attach_property(&radeon_connector->base.base,
2197 rdev->mode_info.underscan_vborder_property,
2199 drm_object_attach_property(&radeon_connector->base.base,
2200 rdev->mode_info.dither_property,
2201 RADEON_FMT_DITHER_DISABLE);
2202 drm_object_attach_property(&radeon_connector->base.base,
2203 dev->mode_config.scaling_mode_property,
2204 DRM_MODE_SCALE_NONE);
2206 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2207 drm_object_attach_property(&radeon_connector->base.base,
2208 rdev->mode_info.audio_property,
2210 radeon_connector->audio = RADEON_AUDIO_AUTO;
2212 if (ASIC_IS_DCE5(rdev))
2213 drm_object_attach_property(&radeon_connector->base.base,
2214 rdev->mode_info.output_csc_property,
2215 RADEON_OUTPUT_CSC_BYPASS);
2216 subpixel_order = SubPixelHorizontalRGB;
2217 connector->interlace_allowed = true;
2218 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2219 connector->doublescan_allowed = true;
2221 connector->doublescan_allowed = false;
2223 case DRM_MODE_CONNECTOR_DisplayPort:
2224 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2225 if (!radeon_dig_connector)
2227 radeon_dig_connector->igp_lane_info = igp_lane_info;
2228 radeon_connector->con_priv = radeon_dig_connector;
2229 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
2230 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2231 if (i2c_bus->valid) {
2232 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2233 if (radeon_connector->ddc_bus)
2236 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2238 subpixel_order = SubPixelHorizontalRGB;
2239 drm_object_attach_property(&radeon_connector->base.base,
2240 rdev->mode_info.coherent_mode_property,
2242 if (ASIC_IS_AVIVO(rdev)) {
2243 drm_object_attach_property(&radeon_connector->base.base,
2244 rdev->mode_info.underscan_property,
2246 drm_object_attach_property(&radeon_connector->base.base,
2247 rdev->mode_info.underscan_hborder_property,
2249 drm_object_attach_property(&radeon_connector->base.base,
2250 rdev->mode_info.underscan_vborder_property,
2252 drm_object_attach_property(&radeon_connector->base.base,
2253 rdev->mode_info.dither_property,
2254 RADEON_FMT_DITHER_DISABLE);
2255 drm_object_attach_property(&radeon_connector->base.base,
2256 dev->mode_config.scaling_mode_property,
2257 DRM_MODE_SCALE_NONE);
2259 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2260 drm_object_attach_property(&radeon_connector->base.base,
2261 rdev->mode_info.audio_property,
2263 radeon_connector->audio = RADEON_AUDIO_AUTO;
2265 if (ASIC_IS_DCE5(rdev))
2266 drm_object_attach_property(&radeon_connector->base.base,
2267 rdev->mode_info.output_csc_property,
2268 RADEON_OUTPUT_CSC_BYPASS);
2269 connector->interlace_allowed = true;
2270 /* in theory with a DP to VGA converter... */
2271 connector->doublescan_allowed = false;
2273 case DRM_MODE_CONNECTOR_eDP:
2274 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2275 if (!radeon_dig_connector)
2277 radeon_dig_connector->igp_lane_info = igp_lane_info;
2278 radeon_connector->con_priv = radeon_dig_connector;
2279 drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
2280 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2281 if (i2c_bus->valid) {
2282 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2283 if (radeon_connector->ddc_bus)
2286 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2288 drm_object_attach_property(&radeon_connector->base.base,
2289 dev->mode_config.scaling_mode_property,
2290 DRM_MODE_SCALE_FULLSCREEN);
2291 subpixel_order = SubPixelHorizontalRGB;
2292 connector->interlace_allowed = false;
2293 connector->doublescan_allowed = false;
2295 case DRM_MODE_CONNECTOR_SVIDEO:
2296 case DRM_MODE_CONNECTOR_Composite:
2297 case DRM_MODE_CONNECTOR_9PinDIN:
2298 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2299 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2300 radeon_connector->dac_load_detect = true;
2301 drm_object_attach_property(&radeon_connector->base.base,
2302 rdev->mode_info.load_detect_property,
2304 drm_object_attach_property(&radeon_connector->base.base,
2305 rdev->mode_info.tv_std_property,
2306 radeon_atombios_get_tv_info(rdev));
2307 /* no HPD on analog connectors */
2308 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2309 connector->interlace_allowed = false;
2310 connector->doublescan_allowed = false;
2312 case DRM_MODE_CONNECTOR_LVDS:
2313 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2314 if (!radeon_dig_connector)
2316 radeon_dig_connector->igp_lane_info = igp_lane_info;
2317 radeon_connector->con_priv = radeon_dig_connector;
2318 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2319 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2320 if (i2c_bus->valid) {
2321 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2322 if (!radeon_connector->ddc_bus)
2323 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2325 drm_object_attach_property(&radeon_connector->base.base,
2326 dev->mode_config.scaling_mode_property,
2327 DRM_MODE_SCALE_FULLSCREEN);
2328 subpixel_order = SubPixelHorizontalRGB;
2329 connector->interlace_allowed = false;
2330 connector->doublescan_allowed = false;
2335 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2336 if (i2c_bus->valid) {
2337 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2338 DRM_CONNECTOR_POLL_DISCONNECT;
2341 connector->polled = DRM_CONNECTOR_POLL_HPD;
2343 connector->display_info.subpixel_order = subpixel_order;
2344 drm_connector_register(connector);
2347 radeon_dp_aux_init(radeon_connector);
2352 drm_connector_cleanup(connector);
2357 radeon_add_legacy_connector(struct drm_device *dev,
2358 uint32_t connector_id,
2359 uint32_t supported_device,
2361 struct radeon_i2c_bus_rec *i2c_bus,
2362 uint16_t connector_object_id,
2363 struct radeon_hpd *hpd)
2365 struct radeon_device *rdev = dev->dev_private;
2366 struct drm_connector *connector;
2367 struct radeon_connector *radeon_connector;
2368 uint32_t subpixel_order = SubPixelNone;
2370 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
2373 /* if the user selected tv=0 don't try and add the connector */
2374 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
2375 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
2376 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
2380 /* see if we already added it */
2381 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2382 radeon_connector = to_radeon_connector(connector);
2383 if (radeon_connector->connector_id == connector_id) {
2384 radeon_connector->devices |= supported_device;
2389 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
2390 if (!radeon_connector)
2393 connector = &radeon_connector->base;
2395 radeon_connector->connector_id = connector_id;
2396 radeon_connector->devices = supported_device;
2397 radeon_connector->connector_object_id = connector_object_id;
2398 radeon_connector->hpd = *hpd;
2400 switch (connector_type) {
2401 case DRM_MODE_CONNECTOR_VGA:
2402 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2403 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2404 if (i2c_bus->valid) {
2405 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2406 if (!radeon_connector->ddc_bus)
2407 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2409 radeon_connector->dac_load_detect = true;
2410 drm_object_attach_property(&radeon_connector->base.base,
2411 rdev->mode_info.load_detect_property,
2413 /* no HPD on analog connectors */
2414 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2415 connector->interlace_allowed = true;
2416 connector->doublescan_allowed = true;
2418 case DRM_MODE_CONNECTOR_DVIA:
2419 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2420 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2421 if (i2c_bus->valid) {
2422 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2423 if (!radeon_connector->ddc_bus)
2424 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2426 radeon_connector->dac_load_detect = true;
2427 drm_object_attach_property(&radeon_connector->base.base,
2428 rdev->mode_info.load_detect_property,
2430 /* no HPD on analog connectors */
2431 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2432 connector->interlace_allowed = true;
2433 connector->doublescan_allowed = true;
2435 case DRM_MODE_CONNECTOR_DVII:
2436 case DRM_MODE_CONNECTOR_DVID:
2437 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2438 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2439 if (i2c_bus->valid) {
2440 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2441 if (!radeon_connector->ddc_bus)
2442 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2444 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2445 radeon_connector->dac_load_detect = true;
2446 drm_object_attach_property(&radeon_connector->base.base,
2447 rdev->mode_info.load_detect_property,
2450 subpixel_order = SubPixelHorizontalRGB;
2451 connector->interlace_allowed = true;
2452 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2453 connector->doublescan_allowed = true;
2455 connector->doublescan_allowed = false;
2457 case DRM_MODE_CONNECTOR_SVIDEO:
2458 case DRM_MODE_CONNECTOR_Composite:
2459 case DRM_MODE_CONNECTOR_9PinDIN:
2460 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2461 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2462 radeon_connector->dac_load_detect = true;
2463 /* RS400,RC410,RS480 chipset seems to report a lot
2464 * of false positive on load detect, we haven't yet
2465 * found a way to make load detect reliable on those
2466 * chipset, thus just disable it for TV.
2468 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
2469 radeon_connector->dac_load_detect = false;
2470 drm_object_attach_property(&radeon_connector->base.base,
2471 rdev->mode_info.load_detect_property,
2472 radeon_connector->dac_load_detect);
2473 drm_object_attach_property(&radeon_connector->base.base,
2474 rdev->mode_info.tv_std_property,
2475 radeon_combios_get_tv_info(rdev));
2476 /* no HPD on analog connectors */
2477 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2478 connector->interlace_allowed = false;
2479 connector->doublescan_allowed = false;
2481 case DRM_MODE_CONNECTOR_LVDS:
2482 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2483 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2484 if (i2c_bus->valid) {
2485 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2486 if (!radeon_connector->ddc_bus)
2487 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2489 drm_object_attach_property(&radeon_connector->base.base,
2490 dev->mode_config.scaling_mode_property,
2491 DRM_MODE_SCALE_FULLSCREEN);
2492 subpixel_order = SubPixelHorizontalRGB;
2493 connector->interlace_allowed = false;
2494 connector->doublescan_allowed = false;
2498 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2499 if (i2c_bus->valid) {
2500 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2501 DRM_CONNECTOR_POLL_DISCONNECT;
2504 connector->polled = DRM_CONNECTOR_POLL_HPD;
2506 connector->display_info.subpixel_order = subpixel_order;
2507 drm_connector_register(connector);
2510 void radeon_setup_mst_connector(struct drm_device *dev)
2512 struct radeon_device *rdev = dev->dev_private;
2513 struct drm_connector *connector;
2514 struct radeon_connector *radeon_connector;
2516 if (!ASIC_IS_DCE5(rdev))
2519 if (radeon_mst == 0)
2522 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2525 radeon_connector = to_radeon_connector(connector);
2527 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
2530 ret = radeon_dp_mst_init(radeon_connector);