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
28 #include "drm_crtc_helper.h"
29 #include "drm_fb_helper.h"
30 #include "radeon_drm.h"
35 radeon_combios_connected_scratch_regs(struct drm_connector *connector,
36 struct drm_encoder *encoder,
39 radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
40 struct drm_encoder *encoder,
43 void radeon_connector_hotplug(struct drm_connector *connector)
45 struct drm_device *dev = connector->dev;
46 struct radeon_device *rdev = dev->dev_private;
47 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
49 if (radeon_connector->hpd.hpd != RADEON_HPD_NONE)
50 radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
52 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
53 if (radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
54 if (radeon_dp_needs_link_train(radeon_connector)) {
55 if (connector->encoder)
56 dp_link_train(connector->encoder, connector);
63 static void radeon_property_change_mode(struct drm_encoder *encoder)
65 struct drm_crtc *crtc = encoder->crtc;
67 if (crtc && crtc->enabled) {
68 drm_crtc_helper_set_mode(crtc, &crtc->mode,
69 crtc->x, crtc->y, crtc->fb);
73 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
75 struct drm_device *dev = connector->dev;
76 struct radeon_device *rdev = dev->dev_private;
77 struct drm_encoder *best_encoder = NULL;
78 struct drm_encoder *encoder = NULL;
79 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
80 struct drm_mode_object *obj;
84 best_encoder = connector_funcs->best_encoder(connector);
86 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
87 if (connector->encoder_ids[i] == 0)
90 obj = drm_mode_object_find(connector->dev,
91 connector->encoder_ids[i],
92 DRM_MODE_OBJECT_ENCODER);
96 encoder = obj_to_encoder(obj);
98 if ((encoder == best_encoder) && (status == connector_status_connected))
103 if (rdev->is_atom_bios)
104 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
106 radeon_combios_connected_scratch_regs(connector, encoder, connected);
111 struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
113 struct drm_mode_object *obj;
114 struct drm_encoder *encoder;
117 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
118 if (connector->encoder_ids[i] == 0)
121 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
125 encoder = obj_to_encoder(obj);
126 if (encoder->encoder_type == encoder_type)
132 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
134 int enc_id = connector->encoder_ids[0];
135 struct drm_mode_object *obj;
136 struct drm_encoder *encoder;
138 /* pick the encoder ids */
140 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
143 encoder = obj_to_encoder(obj);
150 * radeon_connector_analog_encoder_conflict_solve
151 * - search for other connectors sharing this encoder
152 * if priority is true, then set them disconnected if this is connected
153 * if priority is false, set us disconnected if they are connected
155 static enum drm_connector_status
156 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
157 struct drm_encoder *encoder,
158 enum drm_connector_status current_status,
161 struct drm_device *dev = connector->dev;
162 struct drm_connector *conflict;
165 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
166 if (conflict == connector)
169 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
170 if (conflict->encoder_ids[i] == 0)
173 /* if the IDs match */
174 if (conflict->encoder_ids[i] == encoder->base.id) {
175 if (conflict->status != connector_status_connected)
178 if (priority == true) {
179 DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
180 DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
181 conflict->status = connector_status_disconnected;
182 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
184 DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
185 DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
186 current_status = connector_status_disconnected;
192 return current_status;
196 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
198 struct drm_device *dev = encoder->dev;
199 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
200 struct drm_display_mode *mode = NULL;
201 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
203 if (native_mode->hdisplay != 0 &&
204 native_mode->vdisplay != 0 &&
205 native_mode->clock != 0) {
206 mode = drm_mode_duplicate(dev, native_mode);
207 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
208 drm_mode_set_name(mode);
210 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
215 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
217 struct drm_device *dev = encoder->dev;
218 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
219 struct drm_display_mode *mode = NULL;
220 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
225 } common_modes[17] = {
245 for (i = 0; i < 17; i++) {
246 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
247 if (common_modes[i].w > 1024 ||
248 common_modes[i].h > 768)
251 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
252 if (common_modes[i].w > native_mode->hdisplay ||
253 common_modes[i].h > native_mode->vdisplay ||
254 (common_modes[i].w == native_mode->hdisplay &&
255 common_modes[i].h == native_mode->vdisplay))
258 if (common_modes[i].w < 320 || common_modes[i].h < 200)
261 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
262 drm_mode_probed_add(connector, mode);
266 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
269 struct drm_device *dev = connector->dev;
270 struct radeon_device *rdev = dev->dev_private;
271 struct drm_encoder *encoder;
272 struct radeon_encoder *radeon_encoder;
274 if (property == rdev->mode_info.coherent_mode_property) {
275 struct radeon_encoder_atom_dig *dig;
277 /* need to find digital encoder on connector */
278 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
282 radeon_encoder = to_radeon_encoder(encoder);
284 if (!radeon_encoder->enc_priv)
287 dig = radeon_encoder->enc_priv;
288 dig->coherent_mode = val ? true : false;
289 radeon_property_change_mode(&radeon_encoder->base);
292 if (property == rdev->mode_info.tv_std_property) {
293 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
295 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
301 radeon_encoder = to_radeon_encoder(encoder);
302 if (!radeon_encoder->enc_priv)
304 if (rdev->is_atom_bios) {
305 struct radeon_encoder_atom_dac *dac_int;
306 dac_int = radeon_encoder->enc_priv;
307 dac_int->tv_std = val;
309 struct radeon_encoder_tv_dac *dac_int;
310 dac_int = radeon_encoder->enc_priv;
311 dac_int->tv_std = val;
313 radeon_property_change_mode(&radeon_encoder->base);
316 if (property == rdev->mode_info.load_detect_property) {
317 struct radeon_connector *radeon_connector =
318 to_radeon_connector(connector);
321 radeon_connector->dac_load_detect = false;
323 radeon_connector->dac_load_detect = true;
326 if (property == rdev->mode_info.tmds_pll_property) {
327 struct radeon_encoder_int_tmds *tmds = NULL;
329 /* need to find digital encoder on connector */
330 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
334 radeon_encoder = to_radeon_encoder(encoder);
336 tmds = radeon_encoder->enc_priv;
341 if (rdev->is_atom_bios)
342 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
344 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
346 if (val == 1 || ret == false) {
347 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
349 radeon_property_change_mode(&radeon_encoder->base);
355 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
356 struct drm_connector *connector)
358 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
359 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
361 /* Try to get native mode details from EDID if necessary */
362 if (!native_mode->clock) {
363 struct drm_display_mode *t, *mode;
365 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
366 if (mode->hdisplay == native_mode->hdisplay &&
367 mode->vdisplay == native_mode->vdisplay) {
368 *native_mode = *mode;
369 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
370 DRM_INFO("Determined LVDS native mode details from EDID\n");
375 if (!native_mode->clock) {
376 DRM_INFO("No LVDS native mode details, disabling RMX\n");
377 radeon_encoder->rmx_type = RMX_OFF;
381 static int radeon_lvds_get_modes(struct drm_connector *connector)
383 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
384 struct drm_encoder *encoder;
386 struct drm_display_mode *mode;
388 if (radeon_connector->ddc_bus) {
389 ret = radeon_ddc_get_modes(radeon_connector);
391 encoder = radeon_best_single_encoder(connector);
393 radeon_fixup_lvds_native_mode(encoder, connector);
394 /* add scaled modes */
395 radeon_add_common_modes(encoder, connector);
401 encoder = radeon_best_single_encoder(connector);
405 /* we have no EDID modes */
406 mode = radeon_fp_native_mode(encoder);
409 drm_mode_probed_add(connector, mode);
410 /* add scaled modes */
411 radeon_add_common_modes(encoder, connector);
417 static int radeon_lvds_mode_valid(struct drm_connector *connector,
418 struct drm_display_mode *mode)
420 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
422 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
426 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
427 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
429 /* AVIVO hardware supports downscaling modes larger than the panel
430 * to the panel size, but I'm not sure this is desirable.
432 if ((mode->hdisplay > native_mode->hdisplay) ||
433 (mode->vdisplay > native_mode->vdisplay))
436 /* if scaling is disabled, block non-native modes */
437 if (radeon_encoder->rmx_type == RMX_OFF) {
438 if ((mode->hdisplay != native_mode->hdisplay) ||
439 (mode->vdisplay != native_mode->vdisplay))
447 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
449 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
450 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
451 enum drm_connector_status ret = connector_status_disconnected;
454 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
455 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
457 /* check if panel is valid */
458 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
459 ret = connector_status_connected;
463 /* check for edid as well */
464 if (radeon_connector->edid)
465 ret = connector_status_connected;
467 if (radeon_connector->ddc_bus) {
468 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
469 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
470 &radeon_connector->ddc_bus->adapter);
471 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
472 if (radeon_connector->edid)
473 ret = connector_status_connected;
476 /* check acpi lid status ??? */
478 radeon_connector_update_scratch_regs(connector, ret);
482 static void radeon_connector_destroy(struct drm_connector *connector)
484 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
486 if (radeon_connector->ddc_bus)
487 radeon_i2c_destroy(radeon_connector->ddc_bus);
488 if (radeon_connector->edid)
489 kfree(radeon_connector->edid);
490 kfree(radeon_connector->con_priv);
491 drm_sysfs_connector_remove(connector);
492 drm_connector_cleanup(connector);
496 static int radeon_lvds_set_property(struct drm_connector *connector,
497 struct drm_property *property,
500 struct drm_device *dev = connector->dev;
501 struct radeon_encoder *radeon_encoder;
502 enum radeon_rmx_type rmx_type;
505 if (property != dev->mode_config.scaling_mode_property)
508 if (connector->encoder)
509 radeon_encoder = to_radeon_encoder(connector->encoder);
511 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
512 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
516 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
517 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
518 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
520 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
522 if (radeon_encoder->rmx_type == rmx_type)
525 radeon_encoder->rmx_type = rmx_type;
527 radeon_property_change_mode(&radeon_encoder->base);
532 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
533 .get_modes = radeon_lvds_get_modes,
534 .mode_valid = radeon_lvds_mode_valid,
535 .best_encoder = radeon_best_single_encoder,
538 struct drm_connector_funcs radeon_lvds_connector_funcs = {
539 .dpms = drm_helper_connector_dpms,
540 .detect = radeon_lvds_detect,
541 .fill_modes = drm_helper_probe_single_connector_modes,
542 .destroy = radeon_connector_destroy,
543 .set_property = radeon_lvds_set_property,
546 static int radeon_vga_get_modes(struct drm_connector *connector)
548 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
551 ret = radeon_ddc_get_modes(radeon_connector);
556 static int radeon_vga_mode_valid(struct drm_connector *connector,
557 struct drm_display_mode *mode)
559 /* XXX check mode bandwidth */
560 /* XXX verify against max DAC output frequency */
564 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
566 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
567 struct drm_encoder *encoder;
568 struct drm_encoder_helper_funcs *encoder_funcs;
570 enum drm_connector_status ret = connector_status_disconnected;
572 encoder = radeon_best_single_encoder(connector);
574 ret = connector_status_disconnected;
576 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
577 dret = radeon_ddc_probe(radeon_connector);
578 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
580 if (radeon_connector->edid) {
581 kfree(radeon_connector->edid);
582 radeon_connector->edid = NULL;
584 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
585 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
586 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
588 if (!radeon_connector->edid) {
589 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
590 drm_get_connector_name(connector));
591 ret = connector_status_connected;
593 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
595 /* some oems have boards with separate digital and analog connectors
596 * with a shared ddc line (often vga + hdmi)
598 if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
599 kfree(radeon_connector->edid);
600 radeon_connector->edid = NULL;
601 ret = connector_status_disconnected;
603 ret = connector_status_connected;
606 if (radeon_connector->dac_load_detect) {
607 encoder_funcs = encoder->helper_private;
608 ret = encoder_funcs->detect(encoder, connector);
612 if (ret == connector_status_connected)
613 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
614 radeon_connector_update_scratch_regs(connector, ret);
618 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
619 .get_modes = radeon_vga_get_modes,
620 .mode_valid = radeon_vga_mode_valid,
621 .best_encoder = radeon_best_single_encoder,
624 struct drm_connector_funcs radeon_vga_connector_funcs = {
625 .dpms = drm_helper_connector_dpms,
626 .detect = radeon_vga_detect,
627 .fill_modes = drm_helper_probe_single_connector_modes,
628 .destroy = radeon_connector_destroy,
629 .set_property = radeon_connector_set_property,
632 static int radeon_tv_get_modes(struct drm_connector *connector)
634 struct drm_device *dev = connector->dev;
635 struct radeon_device *rdev = dev->dev_private;
636 struct drm_display_mode *tv_mode;
637 struct drm_encoder *encoder;
639 encoder = radeon_best_single_encoder(connector);
643 /* avivo chips can scale any mode */
644 if (rdev->family >= CHIP_RS600)
645 /* add scaled modes */
646 radeon_add_common_modes(encoder, connector);
648 /* only 800x600 is supported right now on pre-avivo chips */
649 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
650 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
651 drm_mode_probed_add(connector, tv_mode);
656 static int radeon_tv_mode_valid(struct drm_connector *connector,
657 struct drm_display_mode *mode)
659 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
660 return MODE_CLOCK_RANGE;
664 static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
666 struct drm_encoder *encoder;
667 struct drm_encoder_helper_funcs *encoder_funcs;
668 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
669 enum drm_connector_status ret = connector_status_disconnected;
671 if (!radeon_connector->dac_load_detect)
674 encoder = radeon_best_single_encoder(connector);
676 ret = connector_status_disconnected;
678 encoder_funcs = encoder->helper_private;
679 ret = encoder_funcs->detect(encoder, connector);
681 if (ret == connector_status_connected)
682 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
683 radeon_connector_update_scratch_regs(connector, ret);
687 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
688 .get_modes = radeon_tv_get_modes,
689 .mode_valid = radeon_tv_mode_valid,
690 .best_encoder = radeon_best_single_encoder,
693 struct drm_connector_funcs radeon_tv_connector_funcs = {
694 .dpms = drm_helper_connector_dpms,
695 .detect = radeon_tv_detect,
696 .fill_modes = drm_helper_probe_single_connector_modes,
697 .destroy = radeon_connector_destroy,
698 .set_property = radeon_connector_set_property,
701 static int radeon_dvi_get_modes(struct drm_connector *connector)
703 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
706 ret = radeon_ddc_get_modes(radeon_connector);
712 * Do a DDC probe, if DDC probe passes, get the full EDID so
713 * we can do analog/digital monitor detection at this point.
714 * If the monitor is an analog monitor or we got no DDC,
715 * we need to find the DAC encoder object for this connector.
716 * If we got no DDC, we do load detection on the DAC encoder object.
717 * If we got analog DDC or load detection passes on the DAC encoder
718 * we have to check if this analog encoder is shared with anyone else (TV)
719 * if its shared we have to set the other connector to disconnected.
721 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
723 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
724 struct drm_encoder *encoder = NULL;
725 struct drm_encoder_helper_funcs *encoder_funcs;
726 struct drm_mode_object *obj;
728 enum drm_connector_status ret = connector_status_disconnected;
731 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
732 dret = radeon_ddc_probe(radeon_connector);
733 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
735 if (radeon_connector->edid) {
736 kfree(radeon_connector->edid);
737 radeon_connector->edid = NULL;
739 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
740 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
741 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
743 if (!radeon_connector->edid) {
744 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
745 drm_get_connector_name(connector));
747 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
749 /* some oems have boards with separate digital and analog connectors
750 * with a shared ddc line (often vga + hdmi)
752 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
753 kfree(radeon_connector->edid);
754 radeon_connector->edid = NULL;
755 ret = connector_status_disconnected;
757 ret = connector_status_connected;
759 /* multiple connectors on the same encoder with the same ddc line
760 * This tends to be HDMI and DVI on the same encoder with the
761 * same ddc line. If the edid says HDMI, consider the HDMI port
762 * connected and the DVI port disconnected. If the edid doesn't
763 * say HDMI, vice versa.
765 if (radeon_connector->shared_ddc && connector_status_connected) {
766 struct drm_device *dev = connector->dev;
767 struct drm_connector *list_connector;
768 struct radeon_connector *list_radeon_connector;
769 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
770 if (connector == list_connector)
772 list_radeon_connector = to_radeon_connector(list_connector);
773 if (radeon_connector->devices == list_radeon_connector->devices) {
774 if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
775 if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
776 kfree(radeon_connector->edid);
777 radeon_connector->edid = NULL;
778 ret = connector_status_disconnected;
781 if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
782 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
783 kfree(radeon_connector->edid);
784 radeon_connector->edid = NULL;
785 ret = connector_status_disconnected;
794 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
797 /* find analog encoder */
798 if (radeon_connector->dac_load_detect) {
799 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
800 if (connector->encoder_ids[i] == 0)
803 obj = drm_mode_object_find(connector->dev,
804 connector->encoder_ids[i],
805 DRM_MODE_OBJECT_ENCODER);
809 encoder = obj_to_encoder(obj);
811 encoder_funcs = encoder->helper_private;
812 if (encoder_funcs->detect) {
813 if (ret != connector_status_connected) {
814 ret = encoder_funcs->detect(encoder, connector);
815 if (ret == connector_status_connected) {
816 radeon_connector->use_digital = false;
824 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
826 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
830 /* updated in get modes as well since we need to know if it's analog or digital */
831 radeon_connector_update_scratch_regs(connector, ret);
835 /* okay need to be smart in here about which encoder to pick */
836 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
838 int enc_id = connector->encoder_ids[0];
839 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
840 struct drm_mode_object *obj;
841 struct drm_encoder *encoder;
843 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
844 if (connector->encoder_ids[i] == 0)
847 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
851 encoder = obj_to_encoder(obj);
853 if (radeon_connector->use_digital == true) {
854 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
857 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
858 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
863 /* see if we have a default encoder TODO */
865 /* then check use digitial */
866 /* pick the first one */
868 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
871 encoder = obj_to_encoder(obj);
877 static void radeon_dvi_force(struct drm_connector *connector)
879 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
880 if (connector->force == DRM_FORCE_ON)
881 radeon_connector->use_digital = false;
882 if (connector->force == DRM_FORCE_ON_DIGITAL)
883 radeon_connector->use_digital = true;
886 static int radeon_dvi_mode_valid(struct drm_connector *connector,
887 struct drm_display_mode *mode)
889 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
891 /* XXX check mode bandwidth */
893 if (radeon_connector->use_digital && (mode->clock > 165000)) {
894 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
895 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
896 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
899 return MODE_CLOCK_HIGH;
904 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
905 .get_modes = radeon_dvi_get_modes,
906 .mode_valid = radeon_dvi_mode_valid,
907 .best_encoder = radeon_dvi_encoder,
910 struct drm_connector_funcs radeon_dvi_connector_funcs = {
911 .dpms = drm_helper_connector_dpms,
912 .detect = radeon_dvi_detect,
913 .fill_modes = drm_helper_probe_single_connector_modes,
914 .set_property = radeon_connector_set_property,
915 .destroy = radeon_connector_destroy,
916 .force = radeon_dvi_force,
919 static void radeon_dp_connector_destroy(struct drm_connector *connector)
921 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
922 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
924 if (radeon_connector->ddc_bus)
925 radeon_i2c_destroy(radeon_connector->ddc_bus);
926 if (radeon_connector->edid)
927 kfree(radeon_connector->edid);
928 if (radeon_dig_connector->dp_i2c_bus)
929 radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
930 kfree(radeon_connector->con_priv);
931 drm_sysfs_connector_remove(connector);
932 drm_connector_cleanup(connector);
936 static int radeon_dp_get_modes(struct drm_connector *connector)
938 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
941 ret = radeon_ddc_get_modes(radeon_connector);
945 static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
947 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
948 enum drm_connector_status ret = connector_status_disconnected;
949 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
952 if (radeon_connector->edid) {
953 kfree(radeon_connector->edid);
954 radeon_connector->edid = NULL;
957 sink_type = radeon_dp_getsinktype(radeon_connector);
958 if (sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
959 if (radeon_dp_getdpcd(radeon_connector)) {
960 radeon_dig_connector->dp_sink_type = sink_type;
961 ret = connector_status_connected;
964 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
965 if (radeon_ddc_probe(radeon_connector)) {
966 radeon_dig_connector->dp_sink_type = sink_type;
967 ret = connector_status_connected;
969 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
975 static int radeon_dp_mode_valid(struct drm_connector *connector,
976 struct drm_display_mode *mode)
978 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
979 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
981 /* XXX check mode bandwidth */
983 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
984 return radeon_dp_mode_valid_helper(radeon_connector, mode);
989 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
990 .get_modes = radeon_dp_get_modes,
991 .mode_valid = radeon_dp_mode_valid,
992 .best_encoder = radeon_dvi_encoder,
995 struct drm_connector_funcs radeon_dp_connector_funcs = {
996 .dpms = drm_helper_connector_dpms,
997 .detect = radeon_dp_detect,
998 .fill_modes = drm_helper_probe_single_connector_modes,
999 .set_property = radeon_connector_set_property,
1000 .destroy = radeon_dp_connector_destroy,
1001 .force = radeon_dvi_force,
1005 radeon_add_atom_connector(struct drm_device *dev,
1006 uint32_t connector_id,
1007 uint32_t supported_device,
1009 struct radeon_i2c_bus_rec *i2c_bus,
1011 uint32_t igp_lane_info,
1012 uint16_t connector_object_id,
1013 struct radeon_hpd *hpd)
1015 struct radeon_device *rdev = dev->dev_private;
1016 struct drm_connector *connector;
1017 struct radeon_connector *radeon_connector;
1018 struct radeon_connector_atom_dig *radeon_dig_connector;
1019 uint32_t subpixel_order = SubPixelNone;
1020 bool shared_ddc = false;
1023 /* fixme - tv/cv/din */
1024 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1027 /* see if we already added it */
1028 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1029 radeon_connector = to_radeon_connector(connector);
1030 if (radeon_connector->connector_id == connector_id) {
1031 radeon_connector->devices |= supported_device;
1034 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1035 if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
1036 sizeof(struct radeon_i2c_bus_rec)) == 0) {
1037 radeon_connector->shared_ddc = true;
1043 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1044 if (!radeon_connector)
1047 connector = &radeon_connector->base;
1049 radeon_connector->connector_id = connector_id;
1050 radeon_connector->devices = supported_device;
1051 radeon_connector->shared_ddc = shared_ddc;
1052 radeon_connector->connector_object_id = connector_object_id;
1053 radeon_connector->hpd = *hpd;
1054 switch (connector_type) {
1055 case DRM_MODE_CONNECTOR_VGA:
1056 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1057 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1060 if (i2c_bus->valid) {
1061 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1062 if (!radeon_connector->ddc_bus)
1065 radeon_connector->dac_load_detect = true;
1066 drm_connector_attach_property(&radeon_connector->base,
1067 rdev->mode_info.load_detect_property,
1070 case DRM_MODE_CONNECTOR_DVIA:
1071 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1072 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1075 if (i2c_bus->valid) {
1076 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1077 if (!radeon_connector->ddc_bus)
1080 radeon_connector->dac_load_detect = true;
1081 drm_connector_attach_property(&radeon_connector->base,
1082 rdev->mode_info.load_detect_property,
1085 case DRM_MODE_CONNECTOR_DVII:
1086 case DRM_MODE_CONNECTOR_DVID:
1087 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1088 if (!radeon_dig_connector)
1090 radeon_dig_connector->linkb = linkb;
1091 radeon_dig_connector->igp_lane_info = igp_lane_info;
1092 radeon_connector->con_priv = radeon_dig_connector;
1093 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1094 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1097 if (i2c_bus->valid) {
1098 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1099 if (!radeon_connector->ddc_bus)
1102 subpixel_order = SubPixelHorizontalRGB;
1103 drm_connector_attach_property(&radeon_connector->base,
1104 rdev->mode_info.coherent_mode_property,
1106 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1107 radeon_connector->dac_load_detect = true;
1108 drm_connector_attach_property(&radeon_connector->base,
1109 rdev->mode_info.load_detect_property,
1113 case DRM_MODE_CONNECTOR_HDMIA:
1114 case DRM_MODE_CONNECTOR_HDMIB:
1115 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1116 if (!radeon_dig_connector)
1118 radeon_dig_connector->linkb = linkb;
1119 radeon_dig_connector->igp_lane_info = igp_lane_info;
1120 radeon_connector->con_priv = radeon_dig_connector;
1121 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1122 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1125 if (i2c_bus->valid) {
1126 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
1127 if (!radeon_connector->ddc_bus)
1130 drm_connector_attach_property(&radeon_connector->base,
1131 rdev->mode_info.coherent_mode_property,
1133 subpixel_order = SubPixelHorizontalRGB;
1135 case DRM_MODE_CONNECTOR_DisplayPort:
1136 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1137 if (!radeon_dig_connector)
1139 radeon_dig_connector->linkb = linkb;
1140 radeon_dig_connector->igp_lane_info = igp_lane_info;
1141 radeon_connector->con_priv = radeon_dig_connector;
1142 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1143 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1146 if (i2c_bus->valid) {
1147 /* add DP i2c bus */
1148 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1149 if (!radeon_dig_connector->dp_i2c_bus)
1151 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
1152 if (!radeon_connector->ddc_bus)
1155 subpixel_order = SubPixelHorizontalRGB;
1156 drm_connector_attach_property(&radeon_connector->base,
1157 rdev->mode_info.coherent_mode_property,
1160 case DRM_MODE_CONNECTOR_SVIDEO:
1161 case DRM_MODE_CONNECTOR_Composite:
1162 case DRM_MODE_CONNECTOR_9PinDIN:
1163 if (radeon_tv == 1) {
1164 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1165 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1168 radeon_connector->dac_load_detect = true;
1169 drm_connector_attach_property(&radeon_connector->base,
1170 rdev->mode_info.load_detect_property,
1172 drm_connector_attach_property(&radeon_connector->base,
1173 rdev->mode_info.tv_std_property,
1177 case DRM_MODE_CONNECTOR_LVDS:
1178 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1179 if (!radeon_dig_connector)
1181 radeon_dig_connector->linkb = linkb;
1182 radeon_dig_connector->igp_lane_info = igp_lane_info;
1183 radeon_connector->con_priv = radeon_dig_connector;
1184 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1185 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1188 if (i2c_bus->valid) {
1189 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1190 if (!radeon_connector->ddc_bus)
1193 drm_connector_attach_property(&radeon_connector->base,
1194 dev->mode_config.scaling_mode_property,
1195 DRM_MODE_SCALE_FULLSCREEN);
1196 subpixel_order = SubPixelHorizontalRGB;
1200 connector->display_info.subpixel_order = subpixel_order;
1201 drm_sysfs_connector_add(connector);
1205 if (radeon_connector->ddc_bus)
1206 radeon_i2c_destroy(radeon_connector->ddc_bus);
1207 drm_connector_cleanup(connector);
1212 radeon_add_legacy_connector(struct drm_device *dev,
1213 uint32_t connector_id,
1214 uint32_t supported_device,
1216 struct radeon_i2c_bus_rec *i2c_bus,
1217 uint16_t connector_object_id,
1218 struct radeon_hpd *hpd)
1220 struct radeon_device *rdev = dev->dev_private;
1221 struct drm_connector *connector;
1222 struct radeon_connector *radeon_connector;
1223 uint32_t subpixel_order = SubPixelNone;
1226 /* fixme - tv/cv/din */
1227 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1230 /* see if we already added it */
1231 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1232 radeon_connector = to_radeon_connector(connector);
1233 if (radeon_connector->connector_id == connector_id) {
1234 radeon_connector->devices |= supported_device;
1239 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1240 if (!radeon_connector)
1243 connector = &radeon_connector->base;
1245 radeon_connector->connector_id = connector_id;
1246 radeon_connector->devices = supported_device;
1247 radeon_connector->connector_object_id = connector_object_id;
1248 radeon_connector->hpd = *hpd;
1249 switch (connector_type) {
1250 case DRM_MODE_CONNECTOR_VGA:
1251 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1252 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1255 if (i2c_bus->valid) {
1256 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1257 if (!radeon_connector->ddc_bus)
1260 radeon_connector->dac_load_detect = true;
1261 drm_connector_attach_property(&radeon_connector->base,
1262 rdev->mode_info.load_detect_property,
1265 case DRM_MODE_CONNECTOR_DVIA:
1266 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1267 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1270 if (i2c_bus->valid) {
1271 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1272 if (!radeon_connector->ddc_bus)
1275 radeon_connector->dac_load_detect = true;
1276 drm_connector_attach_property(&radeon_connector->base,
1277 rdev->mode_info.load_detect_property,
1280 case DRM_MODE_CONNECTOR_DVII:
1281 case DRM_MODE_CONNECTOR_DVID:
1282 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1283 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1286 if (i2c_bus->valid) {
1287 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1288 if (!radeon_connector->ddc_bus)
1290 radeon_connector->dac_load_detect = true;
1291 drm_connector_attach_property(&radeon_connector->base,
1292 rdev->mode_info.load_detect_property,
1295 subpixel_order = SubPixelHorizontalRGB;
1297 case DRM_MODE_CONNECTOR_SVIDEO:
1298 case DRM_MODE_CONNECTOR_Composite:
1299 case DRM_MODE_CONNECTOR_9PinDIN:
1300 if (radeon_tv == 1) {
1301 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1302 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1305 radeon_connector->dac_load_detect = true;
1306 /* RS400,RC410,RS480 chipset seems to report a lot
1307 * of false positive on load detect, we haven't yet
1308 * found a way to make load detect reliable on those
1309 * chipset, thus just disable it for TV.
1311 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1312 radeon_connector->dac_load_detect = false;
1313 drm_connector_attach_property(&radeon_connector->base,
1314 rdev->mode_info.load_detect_property,
1316 drm_connector_attach_property(&radeon_connector->base,
1317 rdev->mode_info.tv_std_property,
1321 case DRM_MODE_CONNECTOR_LVDS:
1322 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1323 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1326 if (i2c_bus->valid) {
1327 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1328 if (!radeon_connector->ddc_bus)
1331 drm_connector_attach_property(&radeon_connector->base,
1332 dev->mode_config.scaling_mode_property,
1333 DRM_MODE_SCALE_FULLSCREEN);
1334 subpixel_order = SubPixelHorizontalRGB;
1338 connector->display_info.subpixel_order = subpixel_order;
1339 drm_sysfs_connector_add(connector);
1343 if (radeon_connector->ddc_bus)
1344 radeon_i2c_destroy(radeon_connector->ddc_bus);
1345 drm_connector_cleanup(connector);