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 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
54 if ((radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
55 (radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_eDP)) {
56 if (radeon_dp_needs_link_train(radeon_connector)) {
57 if (connector->encoder)
58 dp_link_train(connector->encoder, connector);
65 static void radeon_property_change_mode(struct drm_encoder *encoder)
67 struct drm_crtc *crtc = encoder->crtc;
69 if (crtc && crtc->enabled) {
70 drm_crtc_helper_set_mode(crtc, &crtc->mode,
71 crtc->x, crtc->y, crtc->fb);
75 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
77 struct drm_device *dev = connector->dev;
78 struct radeon_device *rdev = dev->dev_private;
79 struct drm_encoder *best_encoder = NULL;
80 struct drm_encoder *encoder = NULL;
81 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
82 struct drm_mode_object *obj;
86 best_encoder = connector_funcs->best_encoder(connector);
88 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
89 if (connector->encoder_ids[i] == 0)
92 obj = drm_mode_object_find(connector->dev,
93 connector->encoder_ids[i],
94 DRM_MODE_OBJECT_ENCODER);
98 encoder = obj_to_encoder(obj);
100 if ((encoder == best_encoder) && (status == connector_status_connected))
105 if (rdev->is_atom_bios)
106 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
108 radeon_combios_connected_scratch_regs(connector, encoder, connected);
113 struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
115 struct drm_mode_object *obj;
116 struct drm_encoder *encoder;
119 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
120 if (connector->encoder_ids[i] == 0)
123 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
127 encoder = obj_to_encoder(obj);
128 if (encoder->encoder_type == encoder_type)
134 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
136 int enc_id = connector->encoder_ids[0];
137 struct drm_mode_object *obj;
138 struct drm_encoder *encoder;
140 /* pick the encoder ids */
142 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
145 encoder = obj_to_encoder(obj);
152 * radeon_connector_analog_encoder_conflict_solve
153 * - search for other connectors sharing this encoder
154 * if priority is true, then set them disconnected if this is connected
155 * if priority is false, set us disconnected if they are connected
157 static enum drm_connector_status
158 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
159 struct drm_encoder *encoder,
160 enum drm_connector_status current_status,
163 struct drm_device *dev = connector->dev;
164 struct drm_connector *conflict;
167 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
168 if (conflict == connector)
171 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
172 if (conflict->encoder_ids[i] == 0)
175 /* if the IDs match */
176 if (conflict->encoder_ids[i] == encoder->base.id) {
177 if (conflict->status != connector_status_connected)
180 if (priority == true) {
181 DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
182 DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
183 conflict->status = connector_status_disconnected;
184 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
186 DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
187 DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
188 current_status = connector_status_disconnected;
194 return current_status;
198 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
200 struct drm_device *dev = encoder->dev;
201 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
202 struct drm_display_mode *mode = NULL;
203 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
205 if (native_mode->hdisplay != 0 &&
206 native_mode->vdisplay != 0 &&
207 native_mode->clock != 0) {
208 mode = drm_mode_duplicate(dev, native_mode);
209 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
210 drm_mode_set_name(mode);
212 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
213 } else if (native_mode->hdisplay != 0 &&
214 native_mode->vdisplay != 0) {
215 /* mac laptops without an edid */
216 /* Note that this is not necessarily the exact panel mode,
217 * but an approximation based on the cvt formula. For these
218 * systems we should ideally read the mode info out of the
219 * registers or add a mode table, but this works and is much
222 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
223 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
224 DRM_DEBUG("Adding cvt approximation of native panel mode %s\n", mode->name);
229 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
231 struct drm_device *dev = encoder->dev;
232 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
233 struct drm_display_mode *mode = NULL;
234 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
239 } common_modes[17] = {
259 for (i = 0; i < 17; i++) {
260 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
261 if (common_modes[i].w > 1024 ||
262 common_modes[i].h > 768)
265 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
266 if (common_modes[i].w > native_mode->hdisplay ||
267 common_modes[i].h > native_mode->vdisplay ||
268 (common_modes[i].w == native_mode->hdisplay &&
269 common_modes[i].h == native_mode->vdisplay))
272 if (common_modes[i].w < 320 || common_modes[i].h < 200)
275 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
276 drm_mode_probed_add(connector, mode);
280 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
283 struct drm_device *dev = connector->dev;
284 struct radeon_device *rdev = dev->dev_private;
285 struct drm_encoder *encoder;
286 struct radeon_encoder *radeon_encoder;
288 if (property == rdev->mode_info.coherent_mode_property) {
289 struct radeon_encoder_atom_dig *dig;
291 /* need to find digital encoder on connector */
292 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
296 radeon_encoder = to_radeon_encoder(encoder);
298 if (!radeon_encoder->enc_priv)
301 dig = radeon_encoder->enc_priv;
302 dig->coherent_mode = val ? true : false;
303 radeon_property_change_mode(&radeon_encoder->base);
306 if (property == rdev->mode_info.tv_std_property) {
307 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
309 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
315 radeon_encoder = to_radeon_encoder(encoder);
316 if (!radeon_encoder->enc_priv)
318 if (rdev->is_atom_bios) {
319 struct radeon_encoder_atom_dac *dac_int;
320 dac_int = radeon_encoder->enc_priv;
321 dac_int->tv_std = val;
323 struct radeon_encoder_tv_dac *dac_int;
324 dac_int = radeon_encoder->enc_priv;
325 dac_int->tv_std = val;
327 radeon_property_change_mode(&radeon_encoder->base);
330 if (property == rdev->mode_info.load_detect_property) {
331 struct radeon_connector *radeon_connector =
332 to_radeon_connector(connector);
335 radeon_connector->dac_load_detect = false;
337 radeon_connector->dac_load_detect = true;
340 if (property == rdev->mode_info.tmds_pll_property) {
341 struct radeon_encoder_int_tmds *tmds = NULL;
343 /* need to find digital encoder on connector */
344 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
348 radeon_encoder = to_radeon_encoder(encoder);
350 tmds = radeon_encoder->enc_priv;
355 if (rdev->is_atom_bios)
356 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
358 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
360 if (val == 1 || ret == false) {
361 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
363 radeon_property_change_mode(&radeon_encoder->base);
369 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
370 struct drm_connector *connector)
372 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
373 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
375 /* Try to get native mode details from EDID if necessary */
376 if (!native_mode->clock) {
377 struct drm_display_mode *t, *mode;
379 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
380 if (mode->hdisplay == native_mode->hdisplay &&
381 mode->vdisplay == native_mode->vdisplay) {
382 *native_mode = *mode;
383 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
384 DRM_INFO("Determined LVDS native mode details from EDID\n");
389 if (!native_mode->clock) {
390 DRM_INFO("No LVDS native mode details, disabling RMX\n");
391 radeon_encoder->rmx_type = RMX_OFF;
395 static int radeon_lvds_get_modes(struct drm_connector *connector)
397 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
398 struct drm_encoder *encoder;
400 struct drm_display_mode *mode;
402 if (radeon_connector->ddc_bus) {
403 ret = radeon_ddc_get_modes(radeon_connector);
405 encoder = radeon_best_single_encoder(connector);
407 radeon_fixup_lvds_native_mode(encoder, connector);
408 /* add scaled modes */
409 radeon_add_common_modes(encoder, connector);
415 encoder = radeon_best_single_encoder(connector);
419 /* we have no EDID modes */
420 mode = radeon_fp_native_mode(encoder);
423 drm_mode_probed_add(connector, mode);
424 /* add scaled modes */
425 radeon_add_common_modes(encoder, connector);
431 static int radeon_lvds_mode_valid(struct drm_connector *connector,
432 struct drm_display_mode *mode)
434 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
436 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
440 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
441 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
443 /* AVIVO hardware supports downscaling modes larger than the panel
444 * to the panel size, but I'm not sure this is desirable.
446 if ((mode->hdisplay > native_mode->hdisplay) ||
447 (mode->vdisplay > native_mode->vdisplay))
450 /* if scaling is disabled, block non-native modes */
451 if (radeon_encoder->rmx_type == RMX_OFF) {
452 if ((mode->hdisplay != native_mode->hdisplay) ||
453 (mode->vdisplay != native_mode->vdisplay))
461 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
463 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
464 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
465 enum drm_connector_status ret = connector_status_disconnected;
468 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
469 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
471 /* check if panel is valid */
472 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
473 ret = connector_status_connected;
477 /* check for edid as well */
478 if (radeon_connector->edid)
479 ret = connector_status_connected;
481 if (radeon_connector->ddc_bus) {
482 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
483 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
484 &radeon_connector->ddc_bus->adapter);
485 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
486 if (radeon_connector->edid)
487 ret = connector_status_connected;
490 /* check acpi lid status ??? */
492 radeon_connector_update_scratch_regs(connector, ret);
496 static void radeon_connector_destroy(struct drm_connector *connector)
498 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
500 if (radeon_connector->ddc_bus)
501 radeon_i2c_destroy(radeon_connector->ddc_bus);
502 if (radeon_connector->edid)
503 kfree(radeon_connector->edid);
504 kfree(radeon_connector->con_priv);
505 drm_sysfs_connector_remove(connector);
506 drm_connector_cleanup(connector);
510 static int radeon_lvds_set_property(struct drm_connector *connector,
511 struct drm_property *property,
514 struct drm_device *dev = connector->dev;
515 struct radeon_encoder *radeon_encoder;
516 enum radeon_rmx_type rmx_type;
519 if (property != dev->mode_config.scaling_mode_property)
522 if (connector->encoder)
523 radeon_encoder = to_radeon_encoder(connector->encoder);
525 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
526 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
530 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
531 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
532 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
534 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
536 if (radeon_encoder->rmx_type == rmx_type)
539 radeon_encoder->rmx_type = rmx_type;
541 radeon_property_change_mode(&radeon_encoder->base);
546 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
547 .get_modes = radeon_lvds_get_modes,
548 .mode_valid = radeon_lvds_mode_valid,
549 .best_encoder = radeon_best_single_encoder,
552 struct drm_connector_funcs radeon_lvds_connector_funcs = {
553 .dpms = drm_helper_connector_dpms,
554 .detect = radeon_lvds_detect,
555 .fill_modes = drm_helper_probe_single_connector_modes,
556 .destroy = radeon_connector_destroy,
557 .set_property = radeon_lvds_set_property,
560 static int radeon_vga_get_modes(struct drm_connector *connector)
562 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
565 ret = radeon_ddc_get_modes(radeon_connector);
570 static int radeon_vga_mode_valid(struct drm_connector *connector,
571 struct drm_display_mode *mode)
573 /* XXX check mode bandwidth */
574 /* XXX verify against max DAC output frequency */
578 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
580 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
581 struct drm_encoder *encoder;
582 struct drm_encoder_helper_funcs *encoder_funcs;
584 enum drm_connector_status ret = connector_status_disconnected;
586 encoder = radeon_best_single_encoder(connector);
588 ret = connector_status_disconnected;
590 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
591 dret = radeon_ddc_probe(radeon_connector);
592 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
594 if (radeon_connector->edid) {
595 kfree(radeon_connector->edid);
596 radeon_connector->edid = NULL;
598 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
599 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
600 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
602 if (!radeon_connector->edid) {
603 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
604 drm_get_connector_name(connector));
605 ret = connector_status_connected;
607 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
609 /* some oems have boards with separate digital and analog connectors
610 * with a shared ddc line (often vga + hdmi)
612 if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
613 kfree(radeon_connector->edid);
614 radeon_connector->edid = NULL;
615 ret = connector_status_disconnected;
617 ret = connector_status_connected;
620 if (radeon_connector->dac_load_detect && encoder) {
621 encoder_funcs = encoder->helper_private;
622 ret = encoder_funcs->detect(encoder, connector);
626 if (ret == connector_status_connected)
627 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
628 radeon_connector_update_scratch_regs(connector, ret);
632 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
633 .get_modes = radeon_vga_get_modes,
634 .mode_valid = radeon_vga_mode_valid,
635 .best_encoder = radeon_best_single_encoder,
638 struct drm_connector_funcs radeon_vga_connector_funcs = {
639 .dpms = drm_helper_connector_dpms,
640 .detect = radeon_vga_detect,
641 .fill_modes = drm_helper_probe_single_connector_modes,
642 .destroy = radeon_connector_destroy,
643 .set_property = radeon_connector_set_property,
646 static int radeon_tv_get_modes(struct drm_connector *connector)
648 struct drm_device *dev = connector->dev;
649 struct radeon_device *rdev = dev->dev_private;
650 struct drm_display_mode *tv_mode;
651 struct drm_encoder *encoder;
653 encoder = radeon_best_single_encoder(connector);
657 /* avivo chips can scale any mode */
658 if (rdev->family >= CHIP_RS600)
659 /* add scaled modes */
660 radeon_add_common_modes(encoder, connector);
662 /* only 800x600 is supported right now on pre-avivo chips */
663 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
664 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
665 drm_mode_probed_add(connector, tv_mode);
670 static int radeon_tv_mode_valid(struct drm_connector *connector,
671 struct drm_display_mode *mode)
673 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
674 return MODE_CLOCK_RANGE;
678 static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
680 struct drm_encoder *encoder;
681 struct drm_encoder_helper_funcs *encoder_funcs;
682 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
683 enum drm_connector_status ret = connector_status_disconnected;
685 if (!radeon_connector->dac_load_detect)
688 encoder = radeon_best_single_encoder(connector);
690 ret = connector_status_disconnected;
692 encoder_funcs = encoder->helper_private;
693 ret = encoder_funcs->detect(encoder, connector);
695 if (ret == connector_status_connected)
696 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
697 radeon_connector_update_scratch_regs(connector, ret);
701 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
702 .get_modes = radeon_tv_get_modes,
703 .mode_valid = radeon_tv_mode_valid,
704 .best_encoder = radeon_best_single_encoder,
707 struct drm_connector_funcs radeon_tv_connector_funcs = {
708 .dpms = drm_helper_connector_dpms,
709 .detect = radeon_tv_detect,
710 .fill_modes = drm_helper_probe_single_connector_modes,
711 .destroy = radeon_connector_destroy,
712 .set_property = radeon_connector_set_property,
715 static int radeon_dvi_get_modes(struct drm_connector *connector)
717 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
720 ret = radeon_ddc_get_modes(radeon_connector);
726 * Do a DDC probe, if DDC probe passes, get the full EDID so
727 * we can do analog/digital monitor detection at this point.
728 * If the monitor is an analog monitor or we got no DDC,
729 * we need to find the DAC encoder object for this connector.
730 * If we got no DDC, we do load detection on the DAC encoder object.
731 * If we got analog DDC or load detection passes on the DAC encoder
732 * we have to check if this analog encoder is shared with anyone else (TV)
733 * if its shared we have to set the other connector to disconnected.
735 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
737 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
738 struct drm_encoder *encoder = NULL;
739 struct drm_encoder_helper_funcs *encoder_funcs;
740 struct drm_mode_object *obj;
742 enum drm_connector_status ret = connector_status_disconnected;
745 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
746 dret = radeon_ddc_probe(radeon_connector);
747 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
749 if (radeon_connector->edid) {
750 kfree(radeon_connector->edid);
751 radeon_connector->edid = NULL;
753 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
754 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
755 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
757 if (!radeon_connector->edid) {
758 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
759 drm_get_connector_name(connector));
761 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
763 /* some oems have boards with separate digital and analog connectors
764 * with a shared ddc line (often vga + hdmi)
766 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
767 kfree(radeon_connector->edid);
768 radeon_connector->edid = NULL;
769 ret = connector_status_disconnected;
771 ret = connector_status_connected;
773 /* multiple connectors on the same encoder with the same ddc line
774 * This tends to be HDMI and DVI on the same encoder with the
775 * same ddc line. If the edid says HDMI, consider the HDMI port
776 * connected and the DVI port disconnected. If the edid doesn't
777 * say HDMI, vice versa.
779 if (radeon_connector->shared_ddc && connector_status_connected) {
780 struct drm_device *dev = connector->dev;
781 struct drm_connector *list_connector;
782 struct radeon_connector *list_radeon_connector;
783 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
784 if (connector == list_connector)
786 list_radeon_connector = to_radeon_connector(list_connector);
787 if (radeon_connector->devices == list_radeon_connector->devices) {
788 if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
789 if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
790 kfree(radeon_connector->edid);
791 radeon_connector->edid = NULL;
792 ret = connector_status_disconnected;
795 if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
796 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
797 kfree(radeon_connector->edid);
798 radeon_connector->edid = NULL;
799 ret = connector_status_disconnected;
808 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
811 /* find analog encoder */
812 if (radeon_connector->dac_load_detect) {
813 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
814 if (connector->encoder_ids[i] == 0)
817 obj = drm_mode_object_find(connector->dev,
818 connector->encoder_ids[i],
819 DRM_MODE_OBJECT_ENCODER);
823 encoder = obj_to_encoder(obj);
825 encoder_funcs = encoder->helper_private;
826 if (encoder_funcs->detect) {
827 if (ret != connector_status_connected) {
828 ret = encoder_funcs->detect(encoder, connector);
829 if (ret == connector_status_connected) {
830 radeon_connector->use_digital = false;
838 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
840 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
844 /* updated in get modes as well since we need to know if it's analog or digital */
845 radeon_connector_update_scratch_regs(connector, ret);
849 /* okay need to be smart in here about which encoder to pick */
850 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
852 int enc_id = connector->encoder_ids[0];
853 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
854 struct drm_mode_object *obj;
855 struct drm_encoder *encoder;
857 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
858 if (connector->encoder_ids[i] == 0)
861 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
865 encoder = obj_to_encoder(obj);
867 if (radeon_connector->use_digital == true) {
868 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
871 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
872 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
877 /* see if we have a default encoder TODO */
879 /* then check use digitial */
880 /* pick the first one */
882 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
885 encoder = obj_to_encoder(obj);
891 static void radeon_dvi_force(struct drm_connector *connector)
893 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
894 if (connector->force == DRM_FORCE_ON)
895 radeon_connector->use_digital = false;
896 if (connector->force == DRM_FORCE_ON_DIGITAL)
897 radeon_connector->use_digital = true;
900 static int radeon_dvi_mode_valid(struct drm_connector *connector,
901 struct drm_display_mode *mode)
903 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
905 /* XXX check mode bandwidth */
907 if (radeon_connector->use_digital && (mode->clock > 165000)) {
908 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
909 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
910 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
913 return MODE_CLOCK_HIGH;
918 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
919 .get_modes = radeon_dvi_get_modes,
920 .mode_valid = radeon_dvi_mode_valid,
921 .best_encoder = radeon_dvi_encoder,
924 struct drm_connector_funcs radeon_dvi_connector_funcs = {
925 .dpms = drm_helper_connector_dpms,
926 .detect = radeon_dvi_detect,
927 .fill_modes = drm_helper_probe_single_connector_modes,
928 .set_property = radeon_connector_set_property,
929 .destroy = radeon_connector_destroy,
930 .force = radeon_dvi_force,
933 static void radeon_dp_connector_destroy(struct drm_connector *connector)
935 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
936 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
938 if (radeon_connector->ddc_bus)
939 radeon_i2c_destroy(radeon_connector->ddc_bus);
940 if (radeon_connector->edid)
941 kfree(radeon_connector->edid);
942 if (radeon_dig_connector->dp_i2c_bus)
943 radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
944 kfree(radeon_connector->con_priv);
945 drm_sysfs_connector_remove(connector);
946 drm_connector_cleanup(connector);
950 static int radeon_dp_get_modes(struct drm_connector *connector)
952 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
955 ret = radeon_ddc_get_modes(radeon_connector);
959 static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
961 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
962 enum drm_connector_status ret = connector_status_disconnected;
963 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
966 if (radeon_connector->edid) {
967 kfree(radeon_connector->edid);
968 radeon_connector->edid = NULL;
971 sink_type = radeon_dp_getsinktype(radeon_connector);
972 if ((sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
973 (sink_type == CONNECTOR_OBJECT_ID_eDP)) {
974 if (radeon_dp_getdpcd(radeon_connector)) {
975 radeon_dig_connector->dp_sink_type = sink_type;
976 ret = connector_status_connected;
979 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
980 if (radeon_ddc_probe(radeon_connector)) {
981 radeon_dig_connector->dp_sink_type = sink_type;
982 ret = connector_status_connected;
984 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
990 static int radeon_dp_mode_valid(struct drm_connector *connector,
991 struct drm_display_mode *mode)
993 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
994 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
996 /* XXX check mode bandwidth */
998 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
999 (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1000 return radeon_dp_mode_valid_helper(radeon_connector, mode);
1005 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1006 .get_modes = radeon_dp_get_modes,
1007 .mode_valid = radeon_dp_mode_valid,
1008 .best_encoder = radeon_dvi_encoder,
1011 struct drm_connector_funcs radeon_dp_connector_funcs = {
1012 .dpms = drm_helper_connector_dpms,
1013 .detect = radeon_dp_detect,
1014 .fill_modes = drm_helper_probe_single_connector_modes,
1015 .set_property = radeon_connector_set_property,
1016 .destroy = radeon_dp_connector_destroy,
1017 .force = radeon_dvi_force,
1021 radeon_add_atom_connector(struct drm_device *dev,
1022 uint32_t connector_id,
1023 uint32_t supported_device,
1025 struct radeon_i2c_bus_rec *i2c_bus,
1027 uint32_t igp_lane_info,
1028 uint16_t connector_object_id,
1029 struct radeon_hpd *hpd)
1031 struct radeon_device *rdev = dev->dev_private;
1032 struct drm_connector *connector;
1033 struct radeon_connector *radeon_connector;
1034 struct radeon_connector_atom_dig *radeon_dig_connector;
1035 uint32_t subpixel_order = SubPixelNone;
1036 bool shared_ddc = false;
1039 /* fixme - tv/cv/din */
1040 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1043 /* see if we already added it */
1044 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1045 radeon_connector = to_radeon_connector(connector);
1046 if (radeon_connector->connector_id == connector_id) {
1047 radeon_connector->devices |= supported_device;
1050 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1051 if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
1052 sizeof(struct radeon_i2c_bus_rec)) == 0) {
1053 radeon_connector->shared_ddc = true;
1059 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1060 if (!radeon_connector)
1063 connector = &radeon_connector->base;
1065 radeon_connector->connector_id = connector_id;
1066 radeon_connector->devices = supported_device;
1067 radeon_connector->shared_ddc = shared_ddc;
1068 radeon_connector->connector_object_id = connector_object_id;
1069 radeon_connector->hpd = *hpd;
1070 switch (connector_type) {
1071 case DRM_MODE_CONNECTOR_VGA:
1072 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1073 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1076 if (i2c_bus->valid) {
1077 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1078 if (!radeon_connector->ddc_bus)
1081 radeon_connector->dac_load_detect = true;
1082 drm_connector_attach_property(&radeon_connector->base,
1083 rdev->mode_info.load_detect_property,
1086 case DRM_MODE_CONNECTOR_DVIA:
1087 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1088 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1091 if (i2c_bus->valid) {
1092 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1093 if (!radeon_connector->ddc_bus)
1096 radeon_connector->dac_load_detect = true;
1097 drm_connector_attach_property(&radeon_connector->base,
1098 rdev->mode_info.load_detect_property,
1101 case DRM_MODE_CONNECTOR_DVII:
1102 case DRM_MODE_CONNECTOR_DVID:
1103 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1104 if (!radeon_dig_connector)
1106 radeon_dig_connector->linkb = linkb;
1107 radeon_dig_connector->igp_lane_info = igp_lane_info;
1108 radeon_connector->con_priv = radeon_dig_connector;
1109 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1110 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1113 if (i2c_bus->valid) {
1114 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1115 if (!radeon_connector->ddc_bus)
1118 subpixel_order = SubPixelHorizontalRGB;
1119 drm_connector_attach_property(&radeon_connector->base,
1120 rdev->mode_info.coherent_mode_property,
1122 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1123 radeon_connector->dac_load_detect = true;
1124 drm_connector_attach_property(&radeon_connector->base,
1125 rdev->mode_info.load_detect_property,
1129 case DRM_MODE_CONNECTOR_HDMIA:
1130 case DRM_MODE_CONNECTOR_HDMIB:
1131 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1132 if (!radeon_dig_connector)
1134 radeon_dig_connector->linkb = linkb;
1135 radeon_dig_connector->igp_lane_info = igp_lane_info;
1136 radeon_connector->con_priv = radeon_dig_connector;
1137 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1138 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1141 if (i2c_bus->valid) {
1142 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
1143 if (!radeon_connector->ddc_bus)
1146 drm_connector_attach_property(&radeon_connector->base,
1147 rdev->mode_info.coherent_mode_property,
1149 subpixel_order = SubPixelHorizontalRGB;
1151 case DRM_MODE_CONNECTOR_DisplayPort:
1152 case DRM_MODE_CONNECTOR_eDP:
1153 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1154 if (!radeon_dig_connector)
1156 radeon_dig_connector->linkb = linkb;
1157 radeon_dig_connector->igp_lane_info = igp_lane_info;
1158 radeon_connector->con_priv = radeon_dig_connector;
1159 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1160 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1163 if (i2c_bus->valid) {
1164 /* add DP i2c bus */
1165 if (connector_type == DRM_MODE_CONNECTOR_eDP)
1166 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1168 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1169 if (!radeon_dig_connector->dp_i2c_bus)
1171 if (connector_type == DRM_MODE_CONNECTOR_eDP)
1172 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "eDP");
1174 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
1175 if (!radeon_connector->ddc_bus)
1178 subpixel_order = SubPixelHorizontalRGB;
1179 drm_connector_attach_property(&radeon_connector->base,
1180 rdev->mode_info.coherent_mode_property,
1183 case DRM_MODE_CONNECTOR_SVIDEO:
1184 case DRM_MODE_CONNECTOR_Composite:
1185 case DRM_MODE_CONNECTOR_9PinDIN:
1186 if (radeon_tv == 1) {
1187 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1188 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1191 radeon_connector->dac_load_detect = true;
1192 drm_connector_attach_property(&radeon_connector->base,
1193 rdev->mode_info.load_detect_property,
1195 drm_connector_attach_property(&radeon_connector->base,
1196 rdev->mode_info.tv_std_property,
1197 radeon_atombios_get_tv_info(rdev));
1200 case DRM_MODE_CONNECTOR_LVDS:
1201 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1202 if (!radeon_dig_connector)
1204 radeon_dig_connector->linkb = linkb;
1205 radeon_dig_connector->igp_lane_info = igp_lane_info;
1206 radeon_connector->con_priv = radeon_dig_connector;
1207 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1208 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1211 if (i2c_bus->valid) {
1212 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1213 if (!radeon_connector->ddc_bus)
1216 drm_connector_attach_property(&radeon_connector->base,
1217 dev->mode_config.scaling_mode_property,
1218 DRM_MODE_SCALE_FULLSCREEN);
1219 subpixel_order = SubPixelHorizontalRGB;
1223 connector->display_info.subpixel_order = subpixel_order;
1224 drm_sysfs_connector_add(connector);
1228 if (radeon_connector->ddc_bus)
1229 radeon_i2c_destroy(radeon_connector->ddc_bus);
1230 drm_connector_cleanup(connector);
1235 radeon_add_legacy_connector(struct drm_device *dev,
1236 uint32_t connector_id,
1237 uint32_t supported_device,
1239 struct radeon_i2c_bus_rec *i2c_bus,
1240 uint16_t connector_object_id,
1241 struct radeon_hpd *hpd)
1243 struct radeon_device *rdev = dev->dev_private;
1244 struct drm_connector *connector;
1245 struct radeon_connector *radeon_connector;
1246 uint32_t subpixel_order = SubPixelNone;
1249 /* fixme - tv/cv/din */
1250 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1253 /* see if we already added it */
1254 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1255 radeon_connector = to_radeon_connector(connector);
1256 if (radeon_connector->connector_id == connector_id) {
1257 radeon_connector->devices |= supported_device;
1262 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1263 if (!radeon_connector)
1266 connector = &radeon_connector->base;
1268 radeon_connector->connector_id = connector_id;
1269 radeon_connector->devices = supported_device;
1270 radeon_connector->connector_object_id = connector_object_id;
1271 radeon_connector->hpd = *hpd;
1272 switch (connector_type) {
1273 case DRM_MODE_CONNECTOR_VGA:
1274 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1275 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1278 if (i2c_bus->valid) {
1279 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1280 if (!radeon_connector->ddc_bus)
1283 radeon_connector->dac_load_detect = true;
1284 drm_connector_attach_property(&radeon_connector->base,
1285 rdev->mode_info.load_detect_property,
1288 case DRM_MODE_CONNECTOR_DVIA:
1289 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1290 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1293 if (i2c_bus->valid) {
1294 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1295 if (!radeon_connector->ddc_bus)
1298 radeon_connector->dac_load_detect = true;
1299 drm_connector_attach_property(&radeon_connector->base,
1300 rdev->mode_info.load_detect_property,
1303 case DRM_MODE_CONNECTOR_DVII:
1304 case DRM_MODE_CONNECTOR_DVID:
1305 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1306 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1309 if (i2c_bus->valid) {
1310 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1311 if (!radeon_connector->ddc_bus)
1313 radeon_connector->dac_load_detect = true;
1314 drm_connector_attach_property(&radeon_connector->base,
1315 rdev->mode_info.load_detect_property,
1318 subpixel_order = SubPixelHorizontalRGB;
1320 case DRM_MODE_CONNECTOR_SVIDEO:
1321 case DRM_MODE_CONNECTOR_Composite:
1322 case DRM_MODE_CONNECTOR_9PinDIN:
1323 if (radeon_tv == 1) {
1324 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1325 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1328 radeon_connector->dac_load_detect = true;
1329 /* RS400,RC410,RS480 chipset seems to report a lot
1330 * of false positive on load detect, we haven't yet
1331 * found a way to make load detect reliable on those
1332 * chipset, thus just disable it for TV.
1334 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1335 radeon_connector->dac_load_detect = false;
1336 drm_connector_attach_property(&radeon_connector->base,
1337 rdev->mode_info.load_detect_property,
1339 drm_connector_attach_property(&radeon_connector->base,
1340 rdev->mode_info.tv_std_property,
1341 radeon_combios_get_tv_info(rdev));
1344 case DRM_MODE_CONNECTOR_LVDS:
1345 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1346 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1349 if (i2c_bus->valid) {
1350 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1351 if (!radeon_connector->ddc_bus)
1354 drm_connector_attach_property(&radeon_connector->base,
1355 dev->mode_config.scaling_mode_property,
1356 DRM_MODE_SCALE_FULLSCREEN);
1357 subpixel_order = SubPixelHorizontalRGB;
1361 connector->display_info.subpixel_order = subpixel_order;
1362 drm_sysfs_connector_add(connector);
1366 if (radeon_connector->ddc_bus)
1367 radeon_i2c_destroy(radeon_connector->ddc_bus);
1368 drm_connector_cleanup(connector);