c60d1a44d22a2c7a09705e6fdb087f972652b55c
[sfrench/cifs-2.6.git] / drivers / gpu / drm / radeon / radeon_connectors.c
1 /*
2  * Copyright 2007-8 Advanced Micro Devices, Inc.
3  * Copyright 2008 Red Hat Inc.
4  *
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:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
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.
22  *
23  * Authors: Dave Airlie
24  *          Alex Deucher
25  */
26
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/drm_probe_helper.h>
32 #include <drm/radeon_drm.h>
33 #include "radeon.h"
34 #include "radeon_audio.h"
35 #include "atom.h"
36
37 #include <linux/pm_runtime.h>
38 #include <linux/vga_switcheroo.h>
39
40 static int radeon_dp_handle_hpd(struct drm_connector *connector)
41 {
42         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
43         int ret;
44
45         ret = radeon_dp_mst_check_status(radeon_connector);
46         if (ret == -EINVAL)
47                 return 1;
48         return 0;
49 }
50 void radeon_connector_hotplug(struct drm_connector *connector)
51 {
52         struct drm_device *dev = connector->dev;
53         struct radeon_device *rdev = dev->dev_private;
54         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
55
56         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
57                 struct radeon_connector_atom_dig *dig_connector =
58                         radeon_connector->con_priv;
59
60                 if (radeon_connector->is_mst_connector)
61                         return;
62                 if (dig_connector->is_mst) {
63                         radeon_dp_handle_hpd(connector);
64                         return;
65                 }
66         }
67         /* bail if the connector does not have hpd pin, e.g.,
68          * VGA, TV, etc.
69          */
70         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
71                 return;
72
73         radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
74
75         /* if the connector is already off, don't turn it back on */
76         /* FIXME: This access isn't protected by any locks. */
77         if (connector->dpms != DRM_MODE_DPMS_ON)
78                 return;
79
80         /* just deal with DP (not eDP) here. */
81         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
82                 struct radeon_connector_atom_dig *dig_connector =
83                         radeon_connector->con_priv;
84
85                 /* if existing sink type was not DP no need to retrain */
86                 if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
87                         return;
88
89                 /* first get sink type as it may be reset after (un)plug */
90                 dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
91                 /* don't do anything if sink is not display port, i.e.,
92                  * passive dp->(dvi|hdmi) adaptor
93                  */
94                 if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT &&
95                     radeon_hpd_sense(rdev, radeon_connector->hpd.hpd) &&
96                     radeon_dp_needs_link_train(radeon_connector)) {
97                         /* Don't start link training before we have the DPCD */
98                         if (!radeon_dp_getdpcd(radeon_connector))
99                                 return;
100
101                         /* Turn the connector off and back on immediately, which
102                          * will trigger link training
103                          */
104                         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
105                         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
106                 }
107         }
108 }
109
110 static void radeon_property_change_mode(struct drm_encoder *encoder)
111 {
112         struct drm_crtc *crtc = encoder->crtc;
113
114         if (crtc && crtc->enabled) {
115                 drm_crtc_helper_set_mode(crtc, &crtc->mode,
116                                          crtc->x, crtc->y, crtc->primary->fb);
117         }
118 }
119
120 int radeon_get_monitor_bpc(struct drm_connector *connector)
121 {
122         struct drm_device *dev = connector->dev;
123         struct radeon_device *rdev = dev->dev_private;
124         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
125         struct radeon_connector_atom_dig *dig_connector;
126         int bpc = 8;
127         int mode_clock, max_tmds_clock;
128
129         switch (connector->connector_type) {
130         case DRM_MODE_CONNECTOR_DVII:
131         case DRM_MODE_CONNECTOR_HDMIB:
132                 if (radeon_connector->use_digital) {
133                         if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
134                                 if (connector->display_info.bpc)
135                                         bpc = connector->display_info.bpc;
136                         }
137                 }
138                 break;
139         case DRM_MODE_CONNECTOR_DVID:
140         case DRM_MODE_CONNECTOR_HDMIA:
141                 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
142                         if (connector->display_info.bpc)
143                                 bpc = connector->display_info.bpc;
144                 }
145                 break;
146         case DRM_MODE_CONNECTOR_DisplayPort:
147                 dig_connector = radeon_connector->con_priv;
148                 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
149                     (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
150                     drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
151                         if (connector->display_info.bpc)
152                                 bpc = connector->display_info.bpc;
153                 }
154                 break;
155         case DRM_MODE_CONNECTOR_eDP:
156         case DRM_MODE_CONNECTOR_LVDS:
157                 if (connector->display_info.bpc)
158                         bpc = connector->display_info.bpc;
159                 else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
160                         const struct drm_connector_helper_funcs *connector_funcs =
161                                 connector->helper_private;
162                         struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
163                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
164                         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
165
166                         if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
167                                 bpc = 6;
168                         else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
169                                 bpc = 8;
170                 }
171                 break;
172         }
173
174         if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
175                 /* hdmi deep color only implemented on DCE4+ */
176                 if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
177                         DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
178                                           connector->name, bpc);
179                         bpc = 8;
180                 }
181
182                 /*
183                  * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
184                  * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
185                  * 12 bpc is always supported on hdmi deep color sinks, as this is
186                  * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
187                  */
188                 if (bpc > 12) {
189                         DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
190                                           connector->name, bpc);
191                         bpc = 12;
192                 }
193
194                 /* Any defined maximum tmds clock limit we must not exceed? */
195                 if (connector->display_info.max_tmds_clock > 0) {
196                         /* mode_clock is clock in kHz for mode to be modeset on this connector */
197                         mode_clock = radeon_connector->pixelclock_for_modeset;
198
199                         /* Maximum allowable input clock in kHz */
200                         max_tmds_clock = connector->display_info.max_tmds_clock;
201
202                         DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
203                                           connector->name, mode_clock, max_tmds_clock);
204
205                         /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
206                         if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
207                                 if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
208                                         (mode_clock * 5/4 <= max_tmds_clock))
209                                         bpc = 10;
210                                 else
211                                         bpc = 8;
212
213                                 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
214                                                   connector->name, bpc);
215                         }
216
217                         if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
218                                 bpc = 8;
219                                 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
220                                                   connector->name, bpc);
221                         }
222                 }
223                 else if (bpc > 8) {
224                         /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
225                         DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
226                                           connector->name);
227                         bpc = 8;
228                 }
229         }
230
231         if ((radeon_deep_color == 0) && (bpc > 8)) {
232                 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
233                                   connector->name);
234                 bpc = 8;
235         }
236
237         DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
238                           connector->name, connector->display_info.bpc, bpc);
239
240         return bpc;
241 }
242
243 static void
244 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
245 {
246         struct drm_device *dev = connector->dev;
247         struct radeon_device *rdev = dev->dev_private;
248         struct drm_encoder *best_encoder;
249         struct drm_encoder *encoder;
250         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
251         bool connected;
252         int i;
253
254         best_encoder = connector_funcs->best_encoder(connector);
255
256         drm_connector_for_each_possible_encoder(connector, encoder, i) {
257                 if ((encoder == best_encoder) && (status == connector_status_connected))
258                         connected = true;
259                 else
260                         connected = false;
261
262                 if (rdev->is_atom_bios)
263                         radeon_atombios_connected_scratch_regs(connector, encoder, connected);
264                 else
265                         radeon_combios_connected_scratch_regs(connector, encoder, connected);
266         }
267 }
268
269 static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
270 {
271         struct drm_encoder *encoder;
272         int i;
273
274         drm_connector_for_each_possible_encoder(connector, encoder, i) {
275                 if (encoder->encoder_type == encoder_type)
276                         return encoder;
277         }
278
279         return NULL;
280 }
281
282 struct edid *radeon_connector_edid(struct drm_connector *connector)
283 {
284         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
285         struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
286
287         if (radeon_connector->edid) {
288                 return radeon_connector->edid;
289         } else if (edid_blob) {
290                 struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
291                 if (edid)
292                         radeon_connector->edid = edid;
293         }
294         return radeon_connector->edid;
295 }
296
297 static void radeon_connector_get_edid(struct drm_connector *connector)
298 {
299         struct drm_device *dev = connector->dev;
300         struct radeon_device *rdev = dev->dev_private;
301         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
302
303         if (radeon_connector->edid)
304                 return;
305
306         /* on hw with routers, select right port */
307         if (radeon_connector->router.ddc_valid)
308                 radeon_router_select_ddc_port(radeon_connector);
309
310         if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
311              ENCODER_OBJECT_ID_NONE) &&
312             radeon_connector->ddc_bus->has_aux) {
313                 radeon_connector->edid = drm_get_edid(connector,
314                                                       &radeon_connector->ddc_bus->aux.ddc);
315         } else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
316                    (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
317                 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
318
319                 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
320                      dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
321                     radeon_connector->ddc_bus->has_aux)
322                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
323                                                               &radeon_connector->ddc_bus->aux.ddc);
324                 else if (radeon_connector->ddc_bus)
325                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
326                                                               &radeon_connector->ddc_bus->adapter);
327         } else if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC &&
328                    connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
329                    radeon_connector->ddc_bus) {
330                 radeon_connector->edid = drm_get_edid_switcheroo(&radeon_connector->base,
331                                                                  &radeon_connector->ddc_bus->adapter);
332         } else if (radeon_connector->ddc_bus) {
333                 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
334                                                       &radeon_connector->ddc_bus->adapter);
335         }
336
337         if (!radeon_connector->edid) {
338                 /* don't fetch the edid from the vbios if ddc fails and runpm is
339                  * enabled so we report disconnected.
340                  */
341                 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
342                         return;
343
344                 if (rdev->is_atom_bios) {
345                         /* some laptops provide a hardcoded edid in rom for LCDs */
346                         if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
347                              (connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
348                                 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
349                 } else {
350                         /* some servers provide a hardcoded edid in rom for KVMs */
351                         radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
352                 }
353         }
354 }
355
356 static void radeon_connector_free_edid(struct drm_connector *connector)
357 {
358         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
359
360         if (radeon_connector->edid) {
361                 kfree(radeon_connector->edid);
362                 radeon_connector->edid = NULL;
363         }
364 }
365
366 static int radeon_ddc_get_modes(struct drm_connector *connector)
367 {
368         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
369         int ret;
370
371         if (radeon_connector->edid) {
372                 drm_connector_update_edid_property(connector, radeon_connector->edid);
373                 ret = drm_add_edid_modes(connector, radeon_connector->edid);
374                 return ret;
375         }
376         drm_connector_update_edid_property(connector, NULL);
377         return 0;
378 }
379
380 static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
381 {
382         struct drm_encoder *encoder;
383         int i;
384
385         /* pick the first one */
386         drm_connector_for_each_possible_encoder(connector, encoder, i)
387                 return encoder;
388
389         return NULL;
390 }
391
392 static void radeon_get_native_mode(struct drm_connector *connector)
393 {
394         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
395         struct radeon_encoder *radeon_encoder;
396
397         if (encoder == NULL)
398                 return;
399
400         radeon_encoder = to_radeon_encoder(encoder);
401
402         if (!list_empty(&connector->probed_modes)) {
403                 struct drm_display_mode *preferred_mode =
404                         list_first_entry(&connector->probed_modes,
405                                          struct drm_display_mode, head);
406
407                 radeon_encoder->native_mode = *preferred_mode;
408         } else {
409                 radeon_encoder->native_mode.clock = 0;
410         }
411 }
412
413 /*
414  * radeon_connector_analog_encoder_conflict_solve
415  * - search for other connectors sharing this encoder
416  *   if priority is true, then set them disconnected if this is connected
417  *   if priority is false, set us disconnected if they are connected
418  */
419 static enum drm_connector_status
420 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
421                                                struct drm_encoder *encoder,
422                                                enum drm_connector_status current_status,
423                                                bool priority)
424 {
425         struct drm_device *dev = connector->dev;
426         struct drm_connector *conflict;
427         struct radeon_connector *radeon_conflict;
428
429         list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
430                 struct drm_encoder *enc;
431                 int i;
432
433                 if (conflict == connector)
434                         continue;
435
436                 radeon_conflict = to_radeon_connector(conflict);
437
438                 drm_connector_for_each_possible_encoder(conflict, enc, i) {
439                         /* if the IDs match */
440                         if (enc == encoder) {
441                                 if (conflict->status != connector_status_connected)
442                                         continue;
443
444                                 if (radeon_conflict->use_digital)
445                                         continue;
446
447                                 if (priority == true) {
448                                         DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
449                                                       conflict->name);
450                                         DRM_DEBUG_KMS("in favor of %s\n",
451                                                       connector->name);
452                                         conflict->status = connector_status_disconnected;
453                                         radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
454                                 } else {
455                                         DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
456                                                       connector->name);
457                                         DRM_DEBUG_KMS("in favor of %s\n",
458                                                       conflict->name);
459                                         current_status = connector_status_disconnected;
460                                 }
461                                 break;
462                         }
463                 }
464         }
465         return current_status;
466
467 }
468
469 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
470 {
471         struct drm_device *dev = encoder->dev;
472         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
473         struct drm_display_mode *mode = NULL;
474         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
475
476         if (native_mode->hdisplay != 0 &&
477             native_mode->vdisplay != 0 &&
478             native_mode->clock != 0) {
479                 mode = drm_mode_duplicate(dev, native_mode);
480                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
481                 drm_mode_set_name(mode);
482
483                 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
484         } else if (native_mode->hdisplay != 0 &&
485                    native_mode->vdisplay != 0) {
486                 /* mac laptops without an edid */
487                 /* Note that this is not necessarily the exact panel mode,
488                  * but an approximation based on the cvt formula.  For these
489                  * systems we should ideally read the mode info out of the
490                  * registers or add a mode table, but this works and is much
491                  * simpler.
492                  */
493                 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
494                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
495                 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
496         }
497         return mode;
498 }
499
500 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
501 {
502         struct drm_device *dev = encoder->dev;
503         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
504         struct drm_display_mode *mode = NULL;
505         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
506         int i;
507         struct mode_size {
508                 int w;
509                 int h;
510         } common_modes[17] = {
511                 { 640,  480},
512                 { 720,  480},
513                 { 800,  600},
514                 { 848,  480},
515                 {1024,  768},
516                 {1152,  768},
517                 {1280,  720},
518                 {1280,  800},
519                 {1280,  854},
520                 {1280,  960},
521                 {1280, 1024},
522                 {1440,  900},
523                 {1400, 1050},
524                 {1680, 1050},
525                 {1600, 1200},
526                 {1920, 1080},
527                 {1920, 1200}
528         };
529
530         for (i = 0; i < 17; i++) {
531                 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
532                         if (common_modes[i].w > 1024 ||
533                             common_modes[i].h > 768)
534                                 continue;
535                 }
536                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
537                         if (common_modes[i].w > native_mode->hdisplay ||
538                             common_modes[i].h > native_mode->vdisplay ||
539                             (common_modes[i].w == native_mode->hdisplay &&
540                              common_modes[i].h == native_mode->vdisplay))
541                                 continue;
542                 }
543                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
544                         continue;
545
546                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
547                 drm_mode_probed_add(connector, mode);
548         }
549 }
550
551 static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
552                                   uint64_t val)
553 {
554         struct drm_device *dev = connector->dev;
555         struct radeon_device *rdev = dev->dev_private;
556         struct drm_encoder *encoder;
557         struct radeon_encoder *radeon_encoder;
558
559         if (property == rdev->mode_info.coherent_mode_property) {
560                 struct radeon_encoder_atom_dig *dig;
561                 bool new_coherent_mode;
562
563                 /* need to find digital encoder on connector */
564                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
565                 if (!encoder)
566                         return 0;
567
568                 radeon_encoder = to_radeon_encoder(encoder);
569
570                 if (!radeon_encoder->enc_priv)
571                         return 0;
572
573                 dig = radeon_encoder->enc_priv;
574                 new_coherent_mode = val ? true : false;
575                 if (dig->coherent_mode != new_coherent_mode) {
576                         dig->coherent_mode = new_coherent_mode;
577                         radeon_property_change_mode(&radeon_encoder->base);
578                 }
579         }
580
581         if (property == rdev->mode_info.audio_property) {
582                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
583                 /* need to find digital encoder on connector */
584                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
585                 if (!encoder)
586                         return 0;
587
588                 radeon_encoder = to_radeon_encoder(encoder);
589
590                 if (radeon_connector->audio != val) {
591                         radeon_connector->audio = val;
592                         radeon_property_change_mode(&radeon_encoder->base);
593                 }
594         }
595
596         if (property == rdev->mode_info.dither_property) {
597                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
598                 /* need to find digital encoder on connector */
599                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
600                 if (!encoder)
601                         return 0;
602
603                 radeon_encoder = to_radeon_encoder(encoder);
604
605                 if (radeon_connector->dither != val) {
606                         radeon_connector->dither = val;
607                         radeon_property_change_mode(&radeon_encoder->base);
608                 }
609         }
610
611         if (property == rdev->mode_info.underscan_property) {
612                 /* need to find digital encoder on connector */
613                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
614                 if (!encoder)
615                         return 0;
616
617                 radeon_encoder = to_radeon_encoder(encoder);
618
619                 if (radeon_encoder->underscan_type != val) {
620                         radeon_encoder->underscan_type = val;
621                         radeon_property_change_mode(&radeon_encoder->base);
622                 }
623         }
624
625         if (property == rdev->mode_info.underscan_hborder_property) {
626                 /* need to find digital encoder on connector */
627                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
628                 if (!encoder)
629                         return 0;
630
631                 radeon_encoder = to_radeon_encoder(encoder);
632
633                 if (radeon_encoder->underscan_hborder != val) {
634                         radeon_encoder->underscan_hborder = val;
635                         radeon_property_change_mode(&radeon_encoder->base);
636                 }
637         }
638
639         if (property == rdev->mode_info.underscan_vborder_property) {
640                 /* need to find digital encoder on connector */
641                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
642                 if (!encoder)
643                         return 0;
644
645                 radeon_encoder = to_radeon_encoder(encoder);
646
647                 if (radeon_encoder->underscan_vborder != val) {
648                         radeon_encoder->underscan_vborder = val;
649                         radeon_property_change_mode(&radeon_encoder->base);
650                 }
651         }
652
653         if (property == rdev->mode_info.tv_std_property) {
654                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
655                 if (!encoder) {
656                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
657                 }
658
659                 if (!encoder)
660                         return 0;
661
662                 radeon_encoder = to_radeon_encoder(encoder);
663                 if (!radeon_encoder->enc_priv)
664                         return 0;
665                 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
666                         struct radeon_encoder_atom_dac *dac_int;
667                         dac_int = radeon_encoder->enc_priv;
668                         dac_int->tv_std = val;
669                 } else {
670                         struct radeon_encoder_tv_dac *dac_int;
671                         dac_int = radeon_encoder->enc_priv;
672                         dac_int->tv_std = val;
673                 }
674                 radeon_property_change_mode(&radeon_encoder->base);
675         }
676
677         if (property == rdev->mode_info.load_detect_property) {
678                 struct radeon_connector *radeon_connector =
679                         to_radeon_connector(connector);
680
681                 if (val == 0)
682                         radeon_connector->dac_load_detect = false;
683                 else
684                         radeon_connector->dac_load_detect = true;
685         }
686
687         if (property == rdev->mode_info.tmds_pll_property) {
688                 struct radeon_encoder_int_tmds *tmds = NULL;
689                 bool ret = false;
690                 /* need to find digital encoder on connector */
691                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
692                 if (!encoder)
693                         return 0;
694
695                 radeon_encoder = to_radeon_encoder(encoder);
696
697                 tmds = radeon_encoder->enc_priv;
698                 if (!tmds)
699                         return 0;
700
701                 if (val == 0) {
702                         if (rdev->is_atom_bios)
703                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
704                         else
705                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
706                 }
707                 if (val == 1 || ret == false) {
708                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
709                 }
710                 radeon_property_change_mode(&radeon_encoder->base);
711         }
712
713         if (property == dev->mode_config.scaling_mode_property) {
714                 enum radeon_rmx_type rmx_type;
715
716                 if (connector->encoder)
717                         radeon_encoder = to_radeon_encoder(connector->encoder);
718                 else {
719                         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
720                         radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
721                 }
722
723                 switch (val) {
724                 default:
725                 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
726                 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
727                 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
728                 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
729                 }
730                 if (radeon_encoder->rmx_type == rmx_type)
731                         return 0;
732
733                 if ((rmx_type != DRM_MODE_SCALE_NONE) &&
734                     (radeon_encoder->native_mode.clock == 0))
735                         return 0;
736
737                 radeon_encoder->rmx_type = rmx_type;
738
739                 radeon_property_change_mode(&radeon_encoder->base);
740         }
741
742         if (property == rdev->mode_info.output_csc_property) {
743                 if (connector->encoder)
744                         radeon_encoder = to_radeon_encoder(connector->encoder);
745                 else {
746                         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
747                         radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
748                 }
749
750                 if (radeon_encoder->output_csc == val)
751                         return 0;
752
753                 radeon_encoder->output_csc = val;
754
755                 if (connector->encoder->crtc) {
756                         struct drm_crtc *crtc  = connector->encoder->crtc;
757                         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
758
759                         radeon_crtc->output_csc = radeon_encoder->output_csc;
760
761                         /*
762                          * Our .gamma_set assumes the .gamma_store has been
763                          * prefilled and don't care about its arguments.
764                          */
765                         crtc->funcs->gamma_set(crtc, NULL, NULL, NULL, 0, NULL);
766                 }
767         }
768
769         return 0;
770 }
771
772 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
773                                           struct drm_connector *connector)
774 {
775         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
776         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
777         struct drm_display_mode *t, *mode;
778
779         /* If the EDID preferred mode doesn't match the native mode, use it */
780         list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
781                 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
782                         if (mode->hdisplay != native_mode->hdisplay ||
783                             mode->vdisplay != native_mode->vdisplay)
784                                 memcpy(native_mode, mode, sizeof(*mode));
785                 }
786         }
787
788         /* Try to get native mode details from EDID if necessary */
789         if (!native_mode->clock) {
790                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
791                         if (mode->hdisplay == native_mode->hdisplay &&
792                             mode->vdisplay == native_mode->vdisplay) {
793                                 *native_mode = *mode;
794                                 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
795                                 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
796                                 break;
797                         }
798                 }
799         }
800
801         if (!native_mode->clock) {
802                 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
803                 radeon_encoder->rmx_type = RMX_OFF;
804         }
805 }
806
807 static int radeon_lvds_get_modes(struct drm_connector *connector)
808 {
809         struct drm_encoder *encoder;
810         int ret = 0;
811         struct drm_display_mode *mode;
812
813         radeon_connector_get_edid(connector);
814         ret = radeon_ddc_get_modes(connector);
815         if (ret > 0) {
816                 encoder = radeon_best_single_encoder(connector);
817                 if (encoder) {
818                         radeon_fixup_lvds_native_mode(encoder, connector);
819                         /* add scaled modes */
820                         radeon_add_common_modes(encoder, connector);
821                 }
822                 return ret;
823         }
824
825         encoder = radeon_best_single_encoder(connector);
826         if (!encoder)
827                 return 0;
828
829         /* we have no EDID modes */
830         mode = radeon_fp_native_mode(encoder);
831         if (mode) {
832                 ret = 1;
833                 drm_mode_probed_add(connector, mode);
834                 /* add the width/height from vbios tables if available */
835                 connector->display_info.width_mm = mode->width_mm;
836                 connector->display_info.height_mm = mode->height_mm;
837                 /* add scaled modes */
838                 radeon_add_common_modes(encoder, connector);
839         }
840
841         return ret;
842 }
843
844 static enum drm_mode_status radeon_lvds_mode_valid(struct drm_connector *connector,
845                                   struct drm_display_mode *mode)
846 {
847         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
848
849         if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
850                 return MODE_PANEL;
851
852         if (encoder) {
853                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
854                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
855
856                 /* AVIVO hardware supports downscaling modes larger than the panel
857                  * to the panel size, but I'm not sure this is desirable.
858                  */
859                 if ((mode->hdisplay > native_mode->hdisplay) ||
860                     (mode->vdisplay > native_mode->vdisplay))
861                         return MODE_PANEL;
862
863                 /* if scaling is disabled, block non-native modes */
864                 if (radeon_encoder->rmx_type == RMX_OFF) {
865                         if ((mode->hdisplay != native_mode->hdisplay) ||
866                             (mode->vdisplay != native_mode->vdisplay))
867                                 return MODE_PANEL;
868                 }
869         }
870
871         return MODE_OK;
872 }
873
874 static enum drm_connector_status
875 radeon_lvds_detect(struct drm_connector *connector, bool force)
876 {
877         struct drm_device *dev = connector->dev;
878         struct radeon_device *rdev = dev->dev_private;
879         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
880         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
881         enum drm_connector_status ret = connector_status_disconnected;
882         int r;
883
884         if (!drm_kms_helper_is_poll_worker()) {
885                 r = pm_runtime_get_sync(connector->dev->dev);
886                 if (r < 0)
887                         return connector_status_disconnected;
888         }
889
890         if (encoder) {
891                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
892                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
893
894                 /* check if panel is valid */
895                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
896                         ret = connector_status_connected;
897                 /* don't fetch the edid from the vbios if ddc fails and runpm is
898                  * enabled so we report disconnected.
899                  */
900                 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
901                         ret = connector_status_disconnected;
902         }
903
904         /* check for edid as well */
905         radeon_connector_get_edid(connector);
906         if (radeon_connector->edid)
907                 ret = connector_status_connected;
908         /* check acpi lid status ??? */
909
910         radeon_connector_update_scratch_regs(connector, ret);
911
912         if (!drm_kms_helper_is_poll_worker()) {
913                 pm_runtime_mark_last_busy(connector->dev->dev);
914                 pm_runtime_put_autosuspend(connector->dev->dev);
915         }
916
917         return ret;
918 }
919
920 static void radeon_connector_unregister(struct drm_connector *connector)
921 {
922         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
923
924         if (radeon_connector->ddc_bus && radeon_connector->ddc_bus->has_aux) {
925                 drm_dp_aux_unregister(&radeon_connector->ddc_bus->aux);
926                 radeon_connector->ddc_bus->has_aux = false;
927         }
928 }
929
930 static void radeon_connector_destroy(struct drm_connector *connector)
931 {
932         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
933
934         radeon_connector_free_edid(connector);
935         kfree(radeon_connector->con_priv);
936         drm_connector_unregister(connector);
937         drm_connector_cleanup(connector);
938         kfree(connector);
939 }
940
941 static int radeon_lvds_set_property(struct drm_connector *connector,
942                                     struct drm_property *property,
943                                     uint64_t value)
944 {
945         struct drm_device *dev = connector->dev;
946         struct radeon_encoder *radeon_encoder;
947         enum radeon_rmx_type rmx_type;
948
949         DRM_DEBUG_KMS("\n");
950         if (property != dev->mode_config.scaling_mode_property)
951                 return 0;
952
953         if (connector->encoder)
954                 radeon_encoder = to_radeon_encoder(connector->encoder);
955         else {
956                 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
957                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
958         }
959
960         switch (value) {
961         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
962         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
963         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
964         default:
965         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
966         }
967         if (radeon_encoder->rmx_type == rmx_type)
968                 return 0;
969
970         radeon_encoder->rmx_type = rmx_type;
971
972         radeon_property_change_mode(&radeon_encoder->base);
973         return 0;
974 }
975
976
977 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
978         .get_modes = radeon_lvds_get_modes,
979         .mode_valid = radeon_lvds_mode_valid,
980         .best_encoder = radeon_best_single_encoder,
981 };
982
983 static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
984         .dpms = drm_helper_connector_dpms,
985         .detect = radeon_lvds_detect,
986         .fill_modes = drm_helper_probe_single_connector_modes,
987         .early_unregister = radeon_connector_unregister,
988         .destroy = radeon_connector_destroy,
989         .set_property = radeon_lvds_set_property,
990 };
991
992 static int radeon_vga_get_modes(struct drm_connector *connector)
993 {
994         int ret;
995
996         radeon_connector_get_edid(connector);
997         ret = radeon_ddc_get_modes(connector);
998
999         radeon_get_native_mode(connector);
1000
1001         return ret;
1002 }
1003
1004 static enum drm_mode_status radeon_vga_mode_valid(struct drm_connector *connector,
1005                                   struct drm_display_mode *mode)
1006 {
1007         struct drm_device *dev = connector->dev;
1008         struct radeon_device *rdev = dev->dev_private;
1009
1010         /* XXX check mode bandwidth */
1011
1012         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1013                 return MODE_CLOCK_HIGH;
1014
1015         return MODE_OK;
1016 }
1017
1018 static enum drm_connector_status
1019 radeon_vga_detect(struct drm_connector *connector, bool force)
1020 {
1021         struct drm_device *dev = connector->dev;
1022         struct radeon_device *rdev = dev->dev_private;
1023         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1024         struct drm_encoder *encoder;
1025         const struct drm_encoder_helper_funcs *encoder_funcs;
1026         bool dret = false;
1027         enum drm_connector_status ret = connector_status_disconnected;
1028         int r;
1029
1030         if (!drm_kms_helper_is_poll_worker()) {
1031                 r = pm_runtime_get_sync(connector->dev->dev);
1032                 if (r < 0)
1033                         return connector_status_disconnected;
1034         }
1035
1036         encoder = radeon_best_single_encoder(connector);
1037         if (!encoder)
1038                 ret = connector_status_disconnected;
1039
1040         if (radeon_connector->ddc_bus)
1041                 dret = radeon_ddc_probe(radeon_connector, false);
1042         if (dret) {
1043                 radeon_connector->detected_by_load = false;
1044                 radeon_connector_free_edid(connector);
1045                 radeon_connector_get_edid(connector);
1046
1047                 if (!radeon_connector->edid) {
1048                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1049                                         connector->name);
1050                         ret = connector_status_connected;
1051                 } else {
1052                         radeon_connector->use_digital =
1053                                 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1054
1055                         /* some oems have boards with separate digital and analog connectors
1056                          * with a shared ddc line (often vga + hdmi)
1057                          */
1058                         if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
1059                                 radeon_connector_free_edid(connector);
1060                                 ret = connector_status_disconnected;
1061                         } else {
1062                                 ret = connector_status_connected;
1063                         }
1064                 }
1065         } else {
1066
1067                 /* if we aren't forcing don't do destructive polling */
1068                 if (!force) {
1069                         /* only return the previous status if we last
1070                          * detected a monitor via load.
1071                          */
1072                         if (radeon_connector->detected_by_load)
1073                                 ret = connector->status;
1074                         goto out;
1075                 }
1076
1077                 if (radeon_connector->dac_load_detect && encoder) {
1078                         encoder_funcs = encoder->helper_private;
1079                         ret = encoder_funcs->detect(encoder, connector);
1080                         if (ret != connector_status_disconnected)
1081                                 radeon_connector->detected_by_load = true;
1082                 }
1083         }
1084
1085         if (ret == connector_status_connected)
1086                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1087
1088         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1089          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1090          * by other means, assume the CRT is connected and use that EDID.
1091          */
1092         if ((!rdev->is_atom_bios) &&
1093             (ret == connector_status_disconnected) &&
1094             rdev->mode_info.bios_hardcoded_edid_size) {
1095                 ret = connector_status_connected;
1096         }
1097
1098         radeon_connector_update_scratch_regs(connector, ret);
1099
1100 out:
1101         if (!drm_kms_helper_is_poll_worker()) {
1102                 pm_runtime_mark_last_busy(connector->dev->dev);
1103                 pm_runtime_put_autosuspend(connector->dev->dev);
1104         }
1105
1106         return ret;
1107 }
1108
1109 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
1110         .get_modes = radeon_vga_get_modes,
1111         .mode_valid = radeon_vga_mode_valid,
1112         .best_encoder = radeon_best_single_encoder,
1113 };
1114
1115 static const struct drm_connector_funcs radeon_vga_connector_funcs = {
1116         .dpms = drm_helper_connector_dpms,
1117         .detect = radeon_vga_detect,
1118         .fill_modes = drm_helper_probe_single_connector_modes,
1119         .early_unregister = radeon_connector_unregister,
1120         .destroy = radeon_connector_destroy,
1121         .set_property = radeon_connector_set_property,
1122 };
1123
1124 static int radeon_tv_get_modes(struct drm_connector *connector)
1125 {
1126         struct drm_device *dev = connector->dev;
1127         struct radeon_device *rdev = dev->dev_private;
1128         struct drm_display_mode *tv_mode;
1129         struct drm_encoder *encoder;
1130
1131         encoder = radeon_best_single_encoder(connector);
1132         if (!encoder)
1133                 return 0;
1134
1135         /* avivo chips can scale any mode */
1136         if (rdev->family >= CHIP_RS600)
1137                 /* add scaled modes */
1138                 radeon_add_common_modes(encoder, connector);
1139         else {
1140                 /* only 800x600 is supported right now on pre-avivo chips */
1141                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1142                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
1143                 drm_mode_probed_add(connector, tv_mode);
1144         }
1145         return 1;
1146 }
1147
1148 static enum drm_mode_status radeon_tv_mode_valid(struct drm_connector *connector,
1149                                 struct drm_display_mode *mode)
1150 {
1151         if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
1152                 return MODE_CLOCK_RANGE;
1153         return MODE_OK;
1154 }
1155
1156 static enum drm_connector_status
1157 radeon_tv_detect(struct drm_connector *connector, bool force)
1158 {
1159         struct drm_encoder *encoder;
1160         const struct drm_encoder_helper_funcs *encoder_funcs;
1161         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1162         enum drm_connector_status ret = connector_status_disconnected;
1163         int r;
1164
1165         if (!radeon_connector->dac_load_detect)
1166                 return ret;
1167
1168         if (!drm_kms_helper_is_poll_worker()) {
1169                 r = pm_runtime_get_sync(connector->dev->dev);
1170                 if (r < 0)
1171                         return connector_status_disconnected;
1172         }
1173
1174         encoder = radeon_best_single_encoder(connector);
1175         if (!encoder)
1176                 ret = connector_status_disconnected;
1177         else {
1178                 encoder_funcs = encoder->helper_private;
1179                 ret = encoder_funcs->detect(encoder, connector);
1180         }
1181         if (ret == connector_status_connected)
1182                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
1183         radeon_connector_update_scratch_regs(connector, ret);
1184
1185         if (!drm_kms_helper_is_poll_worker()) {
1186                 pm_runtime_mark_last_busy(connector->dev->dev);
1187                 pm_runtime_put_autosuspend(connector->dev->dev);
1188         }
1189
1190         return ret;
1191 }
1192
1193 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1194         .get_modes = radeon_tv_get_modes,
1195         .mode_valid = radeon_tv_mode_valid,
1196         .best_encoder = radeon_best_single_encoder,
1197 };
1198
1199 static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1200         .dpms = drm_helper_connector_dpms,
1201         .detect = radeon_tv_detect,
1202         .fill_modes = drm_helper_probe_single_connector_modes,
1203         .early_unregister = radeon_connector_unregister,
1204         .destroy = radeon_connector_destroy,
1205         .set_property = radeon_connector_set_property,
1206 };
1207
1208 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
1209 {
1210         struct drm_device *dev = connector->dev;
1211         struct radeon_device *rdev = dev->dev_private;
1212         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1213         enum drm_connector_status status;
1214
1215         /* We only trust HPD on R600 and newer ASICS. */
1216         if (rdev->family >= CHIP_R600
1217           && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
1218                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
1219                         status = connector_status_connected;
1220                 else
1221                         status = connector_status_disconnected;
1222                 if (connector->status == status)
1223                         return true;
1224         }
1225
1226         return false;
1227 }
1228
1229 /*
1230  * DVI is complicated
1231  * Do a DDC probe, if DDC probe passes, get the full EDID so
1232  * we can do analog/digital monitor detection at this point.
1233  * If the monitor is an analog monitor or we got no DDC,
1234  * we need to find the DAC encoder object for this connector.
1235  * If we got no DDC, we do load detection on the DAC encoder object.
1236  * If we got analog DDC or load detection passes on the DAC encoder
1237  * we have to check if this analog encoder is shared with anyone else (TV)
1238  * if its shared we have to set the other connector to disconnected.
1239  */
1240 static enum drm_connector_status
1241 radeon_dvi_detect(struct drm_connector *connector, bool force)
1242 {
1243         struct drm_device *dev = connector->dev;
1244         struct radeon_device *rdev = dev->dev_private;
1245         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1246         struct drm_encoder *encoder = NULL;
1247         const struct drm_encoder_helper_funcs *encoder_funcs;
1248         int r;
1249         enum drm_connector_status ret = connector_status_disconnected;
1250         bool dret = false, broken_edid = false;
1251
1252         if (!drm_kms_helper_is_poll_worker()) {
1253                 r = pm_runtime_get_sync(connector->dev->dev);
1254                 if (r < 0)
1255                         return connector_status_disconnected;
1256         }
1257
1258         if (radeon_connector->detected_hpd_without_ddc) {
1259                 force = true;
1260                 radeon_connector->detected_hpd_without_ddc = false;
1261         }
1262
1263         if (!force && radeon_check_hpd_status_unchanged(connector)) {
1264                 ret = connector->status;
1265                 goto exit;
1266         }
1267
1268         if (radeon_connector->ddc_bus) {
1269                 dret = radeon_ddc_probe(radeon_connector, false);
1270
1271                 /* Sometimes the pins required for the DDC probe on DVI
1272                  * connectors don't make contact at the same time that the ones
1273                  * for HPD do. If the DDC probe fails even though we had an HPD
1274                  * signal, try again later */
1275                 if (!dret && !force &&
1276                     connector->status != connector_status_connected) {
1277                         DRM_DEBUG_KMS("hpd detected without ddc, retrying in 1 second\n");
1278                         radeon_connector->detected_hpd_without_ddc = true;
1279                         schedule_delayed_work(&rdev->hotplug_work,
1280                                               msecs_to_jiffies(1000));
1281                         goto exit;
1282                 }
1283         }
1284         if (dret) {
1285                 radeon_connector->detected_by_load = false;
1286                 radeon_connector_free_edid(connector);
1287                 radeon_connector_get_edid(connector);
1288
1289                 if (!radeon_connector->edid) {
1290                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1291                                         connector->name);
1292                         /* rs690 seems to have a problem with connectors not existing and always
1293                          * return a block of 0's. If we see this just stop polling on this output */
1294                         if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
1295                             radeon_connector->base.null_edid_counter) {
1296                                 ret = connector_status_disconnected;
1297                                 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1298                                           connector->name);
1299                                 radeon_connector->ddc_bus = NULL;
1300                         } else {
1301                                 ret = connector_status_connected;
1302                                 broken_edid = true; /* defer use_digital to later */
1303                         }
1304                 } else {
1305                         radeon_connector->use_digital =
1306                                 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1307
1308                         /* some oems have boards with separate digital and analog connectors
1309                          * with a shared ddc line (often vga + hdmi)
1310                          */
1311                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
1312                                 radeon_connector_free_edid(connector);
1313                                 ret = connector_status_disconnected;
1314                         } else {
1315                                 ret = connector_status_connected;
1316                         }
1317                         /* This gets complicated.  We have boards with VGA + HDMI with a
1318                          * shared DDC line and we have boards with DVI-D + HDMI with a shared
1319                          * DDC line.  The latter is more complex because with DVI<->HDMI adapters
1320                          * you don't really know what's connected to which port as both are digital.
1321                          */
1322                         if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1323                                 struct drm_connector *list_connector;
1324                                 struct radeon_connector *list_radeon_connector;
1325                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
1326                                         if (connector == list_connector)
1327                                                 continue;
1328                                         list_radeon_connector = to_radeon_connector(list_connector);
1329                                         if (list_radeon_connector->shared_ddc &&
1330                                             (list_radeon_connector->ddc_bus->rec.i2c_id ==
1331                                              radeon_connector->ddc_bus->rec.i2c_id)) {
1332                                                 /* cases where both connectors are digital */
1333                                                 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1334                                                         /* hpd is our only option in this case */
1335                                                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1336                                                                 radeon_connector_free_edid(connector);
1337                                                                 ret = connector_status_disconnected;
1338                                                         }
1339                                                 }
1340                                         }
1341                                 }
1342                         }
1343                 }
1344         }
1345
1346         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1347                 goto out;
1348
1349         /* DVI-D and HDMI-A are digital only */
1350         if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1351             (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1352                 goto out;
1353
1354         /* if we aren't forcing don't do destructive polling */
1355         if (!force) {
1356                 /* only return the previous status if we last
1357                  * detected a monitor via load.
1358                  */
1359                 if (radeon_connector->detected_by_load)
1360                         ret = connector->status;
1361                 goto out;
1362         }
1363
1364         /* find analog encoder */
1365         if (radeon_connector->dac_load_detect) {
1366                 int i;
1367
1368                 drm_connector_for_each_possible_encoder(connector, encoder, i) {
1369                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1370                             encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1371                                 continue;
1372
1373                         encoder_funcs = encoder->helper_private;
1374                         if (encoder_funcs->detect) {
1375                                 if (!broken_edid) {
1376                                         if (ret != connector_status_connected) {
1377                                                 /* deal with analog monitors without DDC */
1378                                                 ret = encoder_funcs->detect(encoder, connector);
1379                                                 if (ret == connector_status_connected) {
1380                                                         radeon_connector->use_digital = false;
1381                                                 }
1382                                                 if (ret != connector_status_disconnected)
1383                                                         radeon_connector->detected_by_load = true;
1384                                         }
1385                                 } else {
1386                                         enum drm_connector_status lret;
1387                                         /* assume digital unless load detected otherwise */
1388                                         radeon_connector->use_digital = true;
1389                                         lret = encoder_funcs->detect(encoder, connector);
1390                                         DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
1391                                         if (lret == connector_status_connected)
1392                                                 radeon_connector->use_digital = false;
1393                                 }
1394                                 break;
1395                         }
1396                 }
1397         }
1398
1399         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1400             encoder) {
1401                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1402         }
1403
1404         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1405          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1406          * by other means, assume the DFP is connected and use that EDID.  In most
1407          * cases the DVI port is actually a virtual KVM port connected to the service
1408          * processor.
1409          */
1410 out:
1411         if ((!rdev->is_atom_bios) &&
1412             (ret == connector_status_disconnected) &&
1413             rdev->mode_info.bios_hardcoded_edid_size) {
1414                 radeon_connector->use_digital = true;
1415                 ret = connector_status_connected;
1416         }
1417
1418         /* updated in get modes as well since we need to know if it's analog or digital */
1419         radeon_connector_update_scratch_regs(connector, ret);
1420
1421         if ((radeon_audio != 0) && radeon_connector->use_digital) {
1422                 const struct drm_connector_helper_funcs *connector_funcs =
1423                         connector->helper_private;
1424
1425                 encoder = connector_funcs->best_encoder(connector);
1426                 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
1427                         radeon_connector_get_edid(connector);
1428                         radeon_audio_detect(connector, encoder, ret);
1429                 }
1430         }
1431
1432 exit:
1433         if (!drm_kms_helper_is_poll_worker()) {
1434                 pm_runtime_mark_last_busy(connector->dev->dev);
1435                 pm_runtime_put_autosuspend(connector->dev->dev);
1436         }
1437
1438         return ret;
1439 }
1440
1441 /* okay need to be smart in here about which encoder to pick */
1442 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1443 {
1444         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1445         struct drm_encoder *encoder;
1446         int i;
1447
1448         drm_connector_for_each_possible_encoder(connector, encoder, i) {
1449                 if (radeon_connector->use_digital == true) {
1450                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1451                                 return encoder;
1452                 } else {
1453                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1454                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1455                                 return encoder;
1456                 }
1457         }
1458
1459         /* see if we have a default encoder  TODO */
1460
1461         /* then check use digitial */
1462         /* pick the first one */
1463         drm_connector_for_each_possible_encoder(connector, encoder, i)
1464                 return encoder;
1465
1466         return NULL;
1467 }
1468
1469 static void radeon_dvi_force(struct drm_connector *connector)
1470 {
1471         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1472         if (connector->force == DRM_FORCE_ON)
1473                 radeon_connector->use_digital = false;
1474         if (connector->force == DRM_FORCE_ON_DIGITAL)
1475                 radeon_connector->use_digital = true;
1476 }
1477
1478 static enum drm_mode_status radeon_dvi_mode_valid(struct drm_connector *connector,
1479                                   struct drm_display_mode *mode)
1480 {
1481         struct drm_device *dev = connector->dev;
1482         struct radeon_device *rdev = dev->dev_private;
1483         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1484
1485         /* XXX check mode bandwidth */
1486
1487         /* clocks over 135 MHz have heat issues with DVI on RV100 */
1488         if (radeon_connector->use_digital &&
1489             (rdev->family == CHIP_RV100) &&
1490             (mode->clock > 135000))
1491                 return MODE_CLOCK_HIGH;
1492
1493         if (radeon_connector->use_digital && (mode->clock > 165000)) {
1494                 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1495                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1496                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1497                         return MODE_OK;
1498                 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1499                         /* HDMI 1.3+ supports max clock of 340 Mhz */
1500                         if (mode->clock > 340000)
1501                                 return MODE_CLOCK_HIGH;
1502                         else
1503                                 return MODE_OK;
1504                 } else {
1505                         return MODE_CLOCK_HIGH;
1506                 }
1507         }
1508
1509         /* check against the max pixel clock */
1510         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1511                 return MODE_CLOCK_HIGH;
1512
1513         return MODE_OK;
1514 }
1515
1516 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1517         .get_modes = radeon_vga_get_modes,
1518         .mode_valid = radeon_dvi_mode_valid,
1519         .best_encoder = radeon_dvi_encoder,
1520 };
1521
1522 static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1523         .dpms = drm_helper_connector_dpms,
1524         .detect = radeon_dvi_detect,
1525         .fill_modes = drm_helper_probe_single_connector_modes,
1526         .set_property = radeon_connector_set_property,
1527         .early_unregister = radeon_connector_unregister,
1528         .destroy = radeon_connector_destroy,
1529         .force = radeon_dvi_force,
1530 };
1531
1532 static int radeon_dp_get_modes(struct drm_connector *connector)
1533 {
1534         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1535         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1536         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1537         int ret;
1538
1539         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1540             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1541                 struct drm_display_mode *mode;
1542
1543                 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1544                         if (!radeon_dig_connector->edp_on)
1545                                 atombios_set_edp_panel_power(connector,
1546                                                              ATOM_TRANSMITTER_ACTION_POWER_ON);
1547                         radeon_connector_get_edid(connector);
1548                         ret = radeon_ddc_get_modes(connector);
1549                         if (!radeon_dig_connector->edp_on)
1550                                 atombios_set_edp_panel_power(connector,
1551                                                              ATOM_TRANSMITTER_ACTION_POWER_OFF);
1552                 } else {
1553                         /* need to setup ddc on the bridge */
1554                         if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1555                             ENCODER_OBJECT_ID_NONE) {
1556                                 if (encoder)
1557                                         radeon_atom_ext_encoder_setup_ddc(encoder);
1558                         }
1559                         radeon_connector_get_edid(connector);
1560                         ret = radeon_ddc_get_modes(connector);
1561                 }
1562
1563                 if (ret > 0) {
1564                         if (encoder) {
1565                                 radeon_fixup_lvds_native_mode(encoder, connector);
1566                                 /* add scaled modes */
1567                                 radeon_add_common_modes(encoder, connector);
1568                         }
1569                         return ret;
1570                 }
1571
1572                 if (!encoder)
1573                         return 0;
1574
1575                 /* we have no EDID modes */
1576                 mode = radeon_fp_native_mode(encoder);
1577                 if (mode) {
1578                         ret = 1;
1579                         drm_mode_probed_add(connector, mode);
1580                         /* add the width/height from vbios tables if available */
1581                         connector->display_info.width_mm = mode->width_mm;
1582                         connector->display_info.height_mm = mode->height_mm;
1583                         /* add scaled modes */
1584                         radeon_add_common_modes(encoder, connector);
1585                 }
1586         } else {
1587                 /* need to setup ddc on the bridge */
1588                 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1589                         ENCODER_OBJECT_ID_NONE) {
1590                         if (encoder)
1591                                 radeon_atom_ext_encoder_setup_ddc(encoder);
1592                 }
1593                 radeon_connector_get_edid(connector);
1594                 ret = radeon_ddc_get_modes(connector);
1595
1596                 radeon_get_native_mode(connector);
1597         }
1598
1599         return ret;
1600 }
1601
1602 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1603 {
1604         struct drm_encoder *encoder;
1605         struct radeon_encoder *radeon_encoder;
1606         int i;
1607
1608         drm_connector_for_each_possible_encoder(connector, encoder, i) {
1609                 radeon_encoder = to_radeon_encoder(encoder);
1610
1611                 switch (radeon_encoder->encoder_id) {
1612                 case ENCODER_OBJECT_ID_TRAVIS:
1613                 case ENCODER_OBJECT_ID_NUTMEG:
1614                         return radeon_encoder->encoder_id;
1615                 default:
1616                         break;
1617                 }
1618         }
1619
1620         return ENCODER_OBJECT_ID_NONE;
1621 }
1622
1623 static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1624 {
1625         struct drm_encoder *encoder;
1626         struct radeon_encoder *radeon_encoder;
1627         int i;
1628         bool found = false;
1629
1630         drm_connector_for_each_possible_encoder(connector, encoder, i) {
1631                 radeon_encoder = to_radeon_encoder(encoder);
1632                 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1633                         found = true;
1634         }
1635
1636         return found;
1637 }
1638
1639 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1640 {
1641         struct drm_device *dev = connector->dev;
1642         struct radeon_device *rdev = dev->dev_private;
1643
1644         if (ASIC_IS_DCE5(rdev) &&
1645             (rdev->clock.default_dispclk >= 53900) &&
1646             radeon_connector_encoder_is_hbr2(connector)) {
1647                 return true;
1648         }
1649
1650         return false;
1651 }
1652
1653 static enum drm_connector_status
1654 radeon_dp_detect(struct drm_connector *connector, bool force)
1655 {
1656         struct drm_device *dev = connector->dev;
1657         struct radeon_device *rdev = dev->dev_private;
1658         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1659         enum drm_connector_status ret = connector_status_disconnected;
1660         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1661         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1662         int r;
1663
1664         if (radeon_dig_connector->is_mst)
1665                 return connector_status_disconnected;
1666
1667         if (!drm_kms_helper_is_poll_worker()) {
1668                 r = pm_runtime_get_sync(connector->dev->dev);
1669                 if (r < 0)
1670                         return connector_status_disconnected;
1671         }
1672
1673         if (!force && radeon_check_hpd_status_unchanged(connector)) {
1674                 ret = connector->status;
1675                 goto out;
1676         }
1677
1678         radeon_connector_free_edid(connector);
1679
1680         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1681             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1682                 if (encoder) {
1683                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1684                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1685
1686                         /* check if panel is valid */
1687                         if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1688                                 ret = connector_status_connected;
1689                         /* don't fetch the edid from the vbios if ddc fails and runpm is
1690                          * enabled so we report disconnected.
1691                          */
1692                         if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
1693                                 ret = connector_status_disconnected;
1694                 }
1695                 /* eDP is always DP */
1696                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1697                 if (!radeon_dig_connector->edp_on)
1698                         atombios_set_edp_panel_power(connector,
1699                                                      ATOM_TRANSMITTER_ACTION_POWER_ON);
1700                 if (radeon_dp_getdpcd(radeon_connector))
1701                         ret = connector_status_connected;
1702                 if (!radeon_dig_connector->edp_on)
1703                         atombios_set_edp_panel_power(connector,
1704                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
1705         } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1706                    ENCODER_OBJECT_ID_NONE) {
1707                 /* DP bridges are always DP */
1708                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1709                 /* get the DPCD from the bridge */
1710                 radeon_dp_getdpcd(radeon_connector);
1711
1712                 if (encoder) {
1713                         /* setup ddc on the bridge */
1714                         radeon_atom_ext_encoder_setup_ddc(encoder);
1715                         /* bridge chips are always aux */
1716                         if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
1717                                 ret = connector_status_connected;
1718                         else if (radeon_connector->dac_load_detect) { /* try load detection */
1719                                 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1720                                 ret = encoder_funcs->detect(encoder, connector);
1721                         }
1722                 }
1723         } else {
1724                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1725                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1726                         ret = connector_status_connected;
1727                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1728                                 radeon_dp_getdpcd(radeon_connector);
1729                                 r = radeon_dp_mst_probe(radeon_connector);
1730                                 if (r == 1)
1731                                         ret = connector_status_disconnected;
1732                         }
1733                 } else {
1734                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1735                                 if (radeon_dp_getdpcd(radeon_connector)) {
1736                                         r = radeon_dp_mst_probe(radeon_connector);
1737                                         if (r == 1)
1738                                                 ret = connector_status_disconnected;
1739                                         else
1740                                                 ret = connector_status_connected;
1741                                 }
1742                         } else {
1743                                 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1744                                 if (radeon_ddc_probe(radeon_connector, false))
1745                                         ret = connector_status_connected;
1746                         }
1747                 }
1748         }
1749
1750         radeon_connector_update_scratch_regs(connector, ret);
1751
1752         if ((radeon_audio != 0) && encoder) {
1753                 radeon_connector_get_edid(connector);
1754                 radeon_audio_detect(connector, encoder, ret);
1755         }
1756
1757 out:
1758         if (!drm_kms_helper_is_poll_worker()) {
1759                 pm_runtime_mark_last_busy(connector->dev->dev);
1760                 pm_runtime_put_autosuspend(connector->dev->dev);
1761         }
1762
1763         return ret;
1764 }
1765
1766 static enum drm_mode_status radeon_dp_mode_valid(struct drm_connector *connector,
1767                                   struct drm_display_mode *mode)
1768 {
1769         struct drm_device *dev = connector->dev;
1770         struct radeon_device *rdev = dev->dev_private;
1771         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1772         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1773
1774         /* XXX check mode bandwidth */
1775
1776         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1777             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1778                 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1779
1780                 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1781                         return MODE_PANEL;
1782
1783                 if (encoder) {
1784                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1785                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1786
1787                         /* AVIVO hardware supports downscaling modes larger than the panel
1788                          * to the panel size, but I'm not sure this is desirable.
1789                          */
1790                         if ((mode->hdisplay > native_mode->hdisplay) ||
1791                             (mode->vdisplay > native_mode->vdisplay))
1792                                 return MODE_PANEL;
1793
1794                         /* if scaling is disabled, block non-native modes */
1795                         if (radeon_encoder->rmx_type == RMX_OFF) {
1796                                 if ((mode->hdisplay != native_mode->hdisplay) ||
1797                                     (mode->vdisplay != native_mode->vdisplay))
1798                                         return MODE_PANEL;
1799                         }
1800                 }
1801         } else {
1802                 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1803                     (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1804                         return radeon_dp_mode_valid_helper(connector, mode);
1805                 } else {
1806                         if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1807                                 /* HDMI 1.3+ supports max clock of 340 Mhz */
1808                                 if (mode->clock > 340000)
1809                                         return MODE_CLOCK_HIGH;
1810                         } else {
1811                                 if (mode->clock > 165000)
1812                                         return MODE_CLOCK_HIGH;
1813                         }
1814                 }
1815         }
1816
1817         return MODE_OK;
1818 }
1819
1820 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1821         .get_modes = radeon_dp_get_modes,
1822         .mode_valid = radeon_dp_mode_valid,
1823         .best_encoder = radeon_dvi_encoder,
1824 };
1825
1826 static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1827         .dpms = drm_helper_connector_dpms,
1828         .detect = radeon_dp_detect,
1829         .fill_modes = drm_helper_probe_single_connector_modes,
1830         .set_property = radeon_connector_set_property,
1831         .early_unregister = radeon_connector_unregister,
1832         .destroy = radeon_connector_destroy,
1833         .force = radeon_dvi_force,
1834 };
1835
1836 static const struct drm_connector_funcs radeon_edp_connector_funcs = {
1837         .dpms = drm_helper_connector_dpms,
1838         .detect = radeon_dp_detect,
1839         .fill_modes = drm_helper_probe_single_connector_modes,
1840         .set_property = radeon_lvds_set_property,
1841         .early_unregister = radeon_connector_unregister,
1842         .destroy = radeon_connector_destroy,
1843         .force = radeon_dvi_force,
1844 };
1845
1846 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
1847         .dpms = drm_helper_connector_dpms,
1848         .detect = radeon_dp_detect,
1849         .fill_modes = drm_helper_probe_single_connector_modes,
1850         .set_property = radeon_lvds_set_property,
1851         .early_unregister = radeon_connector_unregister,
1852         .destroy = radeon_connector_destroy,
1853         .force = radeon_dvi_force,
1854 };
1855
1856 void
1857 radeon_add_atom_connector(struct drm_device *dev,
1858                           uint32_t connector_id,
1859                           uint32_t supported_device,
1860                           int connector_type,
1861                           struct radeon_i2c_bus_rec *i2c_bus,
1862                           uint32_t igp_lane_info,
1863                           uint16_t connector_object_id,
1864                           struct radeon_hpd *hpd,
1865                           struct radeon_router *router)
1866 {
1867         struct radeon_device *rdev = dev->dev_private;
1868         struct drm_connector *connector;
1869         struct radeon_connector *radeon_connector;
1870         struct radeon_connector_atom_dig *radeon_dig_connector;
1871         struct drm_encoder *encoder;
1872         struct radeon_encoder *radeon_encoder;
1873         uint32_t subpixel_order = SubPixelNone;
1874         bool shared_ddc = false;
1875         bool is_dp_bridge = false;
1876         bool has_aux = false;
1877
1878         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1879                 return;
1880
1881         /* if the user selected tv=0 don't try and add the connector */
1882         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1883              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1884              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1885             (radeon_tv == 0))
1886                 return;
1887
1888         /* see if we already added it */
1889         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1890                 radeon_connector = to_radeon_connector(connector);
1891                 if (radeon_connector->connector_id == connector_id) {
1892                         radeon_connector->devices |= supported_device;
1893                         return;
1894                 }
1895                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1896                         if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1897                                 radeon_connector->shared_ddc = true;
1898                                 shared_ddc = true;
1899                         }
1900                         if (radeon_connector->router_bus && router->ddc_valid &&
1901                             (radeon_connector->router.router_id == router->router_id)) {
1902                                 radeon_connector->shared_ddc = false;
1903                                 shared_ddc = false;
1904                         }
1905                 }
1906         }
1907
1908         /* check if it's a dp bridge */
1909         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1910                 radeon_encoder = to_radeon_encoder(encoder);
1911                 if (radeon_encoder->devices & supported_device) {
1912                         switch (radeon_encoder->encoder_id) {
1913                         case ENCODER_OBJECT_ID_TRAVIS:
1914                         case ENCODER_OBJECT_ID_NUTMEG:
1915                                 is_dp_bridge = true;
1916                                 break;
1917                         default:
1918                                 break;
1919                         }
1920                 }
1921         }
1922
1923         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1924         if (!radeon_connector)
1925                 return;
1926
1927         connector = &radeon_connector->base;
1928
1929         radeon_connector->connector_id = connector_id;
1930         radeon_connector->devices = supported_device;
1931         radeon_connector->shared_ddc = shared_ddc;
1932         radeon_connector->connector_object_id = connector_object_id;
1933         radeon_connector->hpd = *hpd;
1934
1935         radeon_connector->router = *router;
1936         if (router->ddc_valid || router->cd_valid) {
1937                 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1938                 if (!radeon_connector->router_bus)
1939                         DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1940         }
1941
1942         if (is_dp_bridge) {
1943                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1944                 if (!radeon_dig_connector)
1945                         goto failed;
1946                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1947                 radeon_connector->con_priv = radeon_dig_connector;
1948                 if (i2c_bus->valid) {
1949                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1950                         if (radeon_connector->ddc_bus)
1951                                 has_aux = true;
1952                         else
1953                                 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1954                 }
1955                 switch (connector_type) {
1956                 case DRM_MODE_CONNECTOR_VGA:
1957                 case DRM_MODE_CONNECTOR_DVIA:
1958                 default:
1959                         drm_connector_init(dev, &radeon_connector->base,
1960                                            &radeon_dp_connector_funcs, connector_type);
1961                         drm_connector_helper_add(&radeon_connector->base,
1962                                                  &radeon_dp_connector_helper_funcs);
1963                         connector->interlace_allowed = true;
1964                         connector->doublescan_allowed = true;
1965                         radeon_connector->dac_load_detect = true;
1966                         drm_object_attach_property(&radeon_connector->base.base,
1967                                                       rdev->mode_info.load_detect_property,
1968                                                       1);
1969                         drm_object_attach_property(&radeon_connector->base.base,
1970                                                    dev->mode_config.scaling_mode_property,
1971                                                    DRM_MODE_SCALE_NONE);
1972                         if (ASIC_IS_DCE5(rdev))
1973                                 drm_object_attach_property(&radeon_connector->base.base,
1974                                                            rdev->mode_info.output_csc_property,
1975                                                            RADEON_OUTPUT_CSC_BYPASS);
1976                         break;
1977                 case DRM_MODE_CONNECTOR_DVII:
1978                 case DRM_MODE_CONNECTOR_DVID:
1979                 case DRM_MODE_CONNECTOR_HDMIA:
1980                 case DRM_MODE_CONNECTOR_HDMIB:
1981                 case DRM_MODE_CONNECTOR_DisplayPort:
1982                         drm_connector_init(dev, &radeon_connector->base,
1983                                            &radeon_dp_connector_funcs, connector_type);
1984                         drm_connector_helper_add(&radeon_connector->base,
1985                                                  &radeon_dp_connector_helper_funcs);
1986                         drm_object_attach_property(&radeon_connector->base.base,
1987                                                       rdev->mode_info.underscan_property,
1988                                                       UNDERSCAN_OFF);
1989                         drm_object_attach_property(&radeon_connector->base.base,
1990                                                       rdev->mode_info.underscan_hborder_property,
1991                                                       0);
1992                         drm_object_attach_property(&radeon_connector->base.base,
1993                                                       rdev->mode_info.underscan_vborder_property,
1994                                                       0);
1995
1996                         drm_object_attach_property(&radeon_connector->base.base,
1997                                                       dev->mode_config.scaling_mode_property,
1998                                                       DRM_MODE_SCALE_NONE);
1999
2000                         drm_object_attach_property(&radeon_connector->base.base,
2001                                                    rdev->mode_info.dither_property,
2002                                                    RADEON_FMT_DITHER_DISABLE);
2003
2004                         if (radeon_audio != 0) {
2005                                 drm_object_attach_property(&radeon_connector->base.base,
2006                                                            rdev->mode_info.audio_property,
2007                                                            RADEON_AUDIO_AUTO);
2008                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
2009                         }
2010                         if (ASIC_IS_DCE5(rdev))
2011                                 drm_object_attach_property(&radeon_connector->base.base,
2012                                                            rdev->mode_info.output_csc_property,
2013                                                            RADEON_OUTPUT_CSC_BYPASS);
2014
2015                         subpixel_order = SubPixelHorizontalRGB;
2016                         connector->interlace_allowed = true;
2017                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2018                                 connector->doublescan_allowed = true;
2019                         else
2020                                 connector->doublescan_allowed = false;
2021                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2022                                 radeon_connector->dac_load_detect = true;
2023                                 drm_object_attach_property(&radeon_connector->base.base,
2024                                                               rdev->mode_info.load_detect_property,
2025                                                               1);
2026                         }
2027                         break;
2028                 case DRM_MODE_CONNECTOR_LVDS:
2029                 case DRM_MODE_CONNECTOR_eDP:
2030                         drm_connector_init(dev, &radeon_connector->base,
2031                                            &radeon_lvds_bridge_connector_funcs, connector_type);
2032                         drm_connector_helper_add(&radeon_connector->base,
2033                                                  &radeon_dp_connector_helper_funcs);
2034                         drm_object_attach_property(&radeon_connector->base.base,
2035                                                       dev->mode_config.scaling_mode_property,
2036                                                       DRM_MODE_SCALE_FULLSCREEN);
2037                         subpixel_order = SubPixelHorizontalRGB;
2038                         connector->interlace_allowed = false;
2039                         connector->doublescan_allowed = false;
2040                         break;
2041                 }
2042         } else {
2043                 switch (connector_type) {
2044                 case DRM_MODE_CONNECTOR_VGA:
2045                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2046                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2047                         if (i2c_bus->valid) {
2048                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2049                                 if (!radeon_connector->ddc_bus)
2050                                         DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2051                         }
2052                         radeon_connector->dac_load_detect = true;
2053                         drm_object_attach_property(&radeon_connector->base.base,
2054                                                       rdev->mode_info.load_detect_property,
2055                                                       1);
2056                         if (ASIC_IS_AVIVO(rdev))
2057                                 drm_object_attach_property(&radeon_connector->base.base,
2058                                                            dev->mode_config.scaling_mode_property,
2059                                                            DRM_MODE_SCALE_NONE);
2060                         if (ASIC_IS_DCE5(rdev))
2061                                 drm_object_attach_property(&radeon_connector->base.base,
2062                                                            rdev->mode_info.output_csc_property,
2063                                                            RADEON_OUTPUT_CSC_BYPASS);
2064                         /* no HPD on analog connectors */
2065                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2066                         connector->interlace_allowed = true;
2067                         connector->doublescan_allowed = true;
2068                         break;
2069                 case DRM_MODE_CONNECTOR_DVIA:
2070                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2071                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2072                         if (i2c_bus->valid) {
2073                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2074                                 if (!radeon_connector->ddc_bus)
2075                                         DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2076                         }
2077                         radeon_connector->dac_load_detect = true;
2078                         drm_object_attach_property(&radeon_connector->base.base,
2079                                                       rdev->mode_info.load_detect_property,
2080                                                       1);
2081                         if (ASIC_IS_AVIVO(rdev))
2082                                 drm_object_attach_property(&radeon_connector->base.base,
2083                                                            dev->mode_config.scaling_mode_property,
2084                                                            DRM_MODE_SCALE_NONE);
2085                         if (ASIC_IS_DCE5(rdev))
2086                                 drm_object_attach_property(&radeon_connector->base.base,
2087                                                            rdev->mode_info.output_csc_property,
2088                                                            RADEON_OUTPUT_CSC_BYPASS);
2089                         /* no HPD on analog connectors */
2090                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2091                         connector->interlace_allowed = true;
2092                         connector->doublescan_allowed = true;
2093                         break;
2094                 case DRM_MODE_CONNECTOR_DVII:
2095                 case DRM_MODE_CONNECTOR_DVID:
2096                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2097                         if (!radeon_dig_connector)
2098                                 goto failed;
2099                         radeon_dig_connector->igp_lane_info = igp_lane_info;
2100                         radeon_connector->con_priv = radeon_dig_connector;
2101                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2102                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2103                         if (i2c_bus->valid) {
2104                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2105                                 if (!radeon_connector->ddc_bus)
2106                                         DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2107                         }
2108                         subpixel_order = SubPixelHorizontalRGB;
2109                         drm_object_attach_property(&radeon_connector->base.base,
2110                                                       rdev->mode_info.coherent_mode_property,
2111                                                       1);
2112                         if (ASIC_IS_AVIVO(rdev)) {
2113                                 drm_object_attach_property(&radeon_connector->base.base,
2114                                                               rdev->mode_info.underscan_property,
2115                                                               UNDERSCAN_OFF);
2116                                 drm_object_attach_property(&radeon_connector->base.base,
2117                                                               rdev->mode_info.underscan_hborder_property,
2118                                                               0);
2119                                 drm_object_attach_property(&radeon_connector->base.base,
2120                                                               rdev->mode_info.underscan_vborder_property,
2121                                                               0);
2122                                 drm_object_attach_property(&radeon_connector->base.base,
2123                                                            rdev->mode_info.dither_property,
2124                                                            RADEON_FMT_DITHER_DISABLE);
2125                                 drm_object_attach_property(&radeon_connector->base.base,
2126                                                            dev->mode_config.scaling_mode_property,
2127                                                            DRM_MODE_SCALE_NONE);
2128                         }
2129                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2130                                 drm_object_attach_property(&radeon_connector->base.base,
2131                                                            rdev->mode_info.audio_property,
2132                                                            RADEON_AUDIO_AUTO);
2133                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
2134                         }
2135                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2136                                 radeon_connector->dac_load_detect = true;
2137                                 drm_object_attach_property(&radeon_connector->base.base,
2138                                                               rdev->mode_info.load_detect_property,
2139                                                               1);
2140                         }
2141                         if (ASIC_IS_DCE5(rdev))
2142                                 drm_object_attach_property(&radeon_connector->base.base,
2143                                                            rdev->mode_info.output_csc_property,
2144                                                            RADEON_OUTPUT_CSC_BYPASS);
2145                         connector->interlace_allowed = true;
2146                         if (connector_type == DRM_MODE_CONNECTOR_DVII)
2147                                 connector->doublescan_allowed = true;
2148                         else
2149                                 connector->doublescan_allowed = false;
2150                         break;
2151                 case DRM_MODE_CONNECTOR_HDMIA:
2152                 case DRM_MODE_CONNECTOR_HDMIB:
2153                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2154                         if (!radeon_dig_connector)
2155                                 goto failed;
2156                         radeon_dig_connector->igp_lane_info = igp_lane_info;
2157                         radeon_connector->con_priv = radeon_dig_connector;
2158                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2159                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2160                         if (i2c_bus->valid) {
2161                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2162                                 if (!radeon_connector->ddc_bus)
2163                                         DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2164                         }
2165                         drm_object_attach_property(&radeon_connector->base.base,
2166                                                       rdev->mode_info.coherent_mode_property,
2167                                                       1);
2168                         if (ASIC_IS_AVIVO(rdev)) {
2169                                 drm_object_attach_property(&radeon_connector->base.base,
2170                                                               rdev->mode_info.underscan_property,
2171                                                               UNDERSCAN_OFF);
2172                                 drm_object_attach_property(&radeon_connector->base.base,
2173                                                               rdev->mode_info.underscan_hborder_property,
2174                                                               0);
2175                                 drm_object_attach_property(&radeon_connector->base.base,
2176                                                               rdev->mode_info.underscan_vborder_property,
2177                                                               0);
2178                                 drm_object_attach_property(&radeon_connector->base.base,
2179                                                            rdev->mode_info.dither_property,
2180                                                            RADEON_FMT_DITHER_DISABLE);
2181                                 drm_object_attach_property(&radeon_connector->base.base,
2182                                                            dev->mode_config.scaling_mode_property,
2183                                                            DRM_MODE_SCALE_NONE);
2184                         }
2185                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2186                                 drm_object_attach_property(&radeon_connector->base.base,
2187                                                            rdev->mode_info.audio_property,
2188                                                            RADEON_AUDIO_AUTO);
2189                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
2190                         }
2191                         if (ASIC_IS_DCE5(rdev))
2192                                 drm_object_attach_property(&radeon_connector->base.base,
2193                                                            rdev->mode_info.output_csc_property,
2194                                                            RADEON_OUTPUT_CSC_BYPASS);
2195                         subpixel_order = SubPixelHorizontalRGB;
2196                         connector->interlace_allowed = true;
2197                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2198                                 connector->doublescan_allowed = true;
2199                         else
2200                                 connector->doublescan_allowed = false;
2201                         break;
2202                 case DRM_MODE_CONNECTOR_DisplayPort:
2203                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2204                         if (!radeon_dig_connector)
2205                                 goto failed;
2206                         radeon_dig_connector->igp_lane_info = igp_lane_info;
2207                         radeon_connector->con_priv = radeon_dig_connector;
2208                         drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
2209                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2210                         if (i2c_bus->valid) {
2211                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2212                                 if (radeon_connector->ddc_bus)
2213                                         has_aux = true;
2214                                 else
2215                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2216                         }
2217                         subpixel_order = SubPixelHorizontalRGB;
2218                         drm_object_attach_property(&radeon_connector->base.base,
2219                                                       rdev->mode_info.coherent_mode_property,
2220                                                       1);
2221                         if (ASIC_IS_AVIVO(rdev)) {
2222                                 drm_object_attach_property(&radeon_connector->base.base,
2223                                                               rdev->mode_info.underscan_property,
2224                                                               UNDERSCAN_OFF);
2225                                 drm_object_attach_property(&radeon_connector->base.base,
2226                                                               rdev->mode_info.underscan_hborder_property,
2227                                                               0);
2228                                 drm_object_attach_property(&radeon_connector->base.base,
2229                                                               rdev->mode_info.underscan_vborder_property,
2230                                                               0);
2231                                 drm_object_attach_property(&radeon_connector->base.base,
2232                                                            rdev->mode_info.dither_property,
2233                                                            RADEON_FMT_DITHER_DISABLE);
2234                                 drm_object_attach_property(&radeon_connector->base.base,
2235                                                            dev->mode_config.scaling_mode_property,
2236                                                            DRM_MODE_SCALE_NONE);
2237                         }
2238                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2239                                 drm_object_attach_property(&radeon_connector->base.base,
2240                                                            rdev->mode_info.audio_property,
2241                                                            RADEON_AUDIO_AUTO);
2242                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
2243                         }
2244                         if (ASIC_IS_DCE5(rdev))
2245                                 drm_object_attach_property(&radeon_connector->base.base,
2246                                                            rdev->mode_info.output_csc_property,
2247                                                            RADEON_OUTPUT_CSC_BYPASS);
2248                         connector->interlace_allowed = true;
2249                         /* in theory with a DP to VGA converter... */
2250                         connector->doublescan_allowed = false;
2251                         break;
2252                 case DRM_MODE_CONNECTOR_eDP:
2253                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2254                         if (!radeon_dig_connector)
2255                                 goto failed;
2256                         radeon_dig_connector->igp_lane_info = igp_lane_info;
2257                         radeon_connector->con_priv = radeon_dig_connector;
2258                         drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
2259                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2260                         if (i2c_bus->valid) {
2261                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2262                                 if (radeon_connector->ddc_bus)
2263                                         has_aux = true;
2264                                 else
2265                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2266                         }
2267                         drm_object_attach_property(&radeon_connector->base.base,
2268                                                       dev->mode_config.scaling_mode_property,
2269                                                       DRM_MODE_SCALE_FULLSCREEN);
2270                         subpixel_order = SubPixelHorizontalRGB;
2271                         connector->interlace_allowed = false;
2272                         connector->doublescan_allowed = false;
2273                         break;
2274                 case DRM_MODE_CONNECTOR_SVIDEO:
2275                 case DRM_MODE_CONNECTOR_Composite:
2276                 case DRM_MODE_CONNECTOR_9PinDIN:
2277                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2278                         drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2279                         radeon_connector->dac_load_detect = true;
2280                         drm_object_attach_property(&radeon_connector->base.base,
2281                                                       rdev->mode_info.load_detect_property,
2282                                                       1);
2283                         drm_object_attach_property(&radeon_connector->base.base,
2284                                                       rdev->mode_info.tv_std_property,
2285                                                       radeon_atombios_get_tv_info(rdev));
2286                         /* no HPD on analog connectors */
2287                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2288                         connector->interlace_allowed = false;
2289                         connector->doublescan_allowed = false;
2290                         break;
2291                 case DRM_MODE_CONNECTOR_LVDS:
2292                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2293                         if (!radeon_dig_connector)
2294                                 goto failed;
2295                         radeon_dig_connector->igp_lane_info = igp_lane_info;
2296                         radeon_connector->con_priv = radeon_dig_connector;
2297                         drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2298                         drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2299                         if (i2c_bus->valid) {
2300                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2301                                 if (!radeon_connector->ddc_bus)
2302                                         DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2303                         }
2304                         drm_object_attach_property(&radeon_connector->base.base,
2305                                                       dev->mode_config.scaling_mode_property,
2306                                                       DRM_MODE_SCALE_FULLSCREEN);
2307                         subpixel_order = SubPixelHorizontalRGB;
2308                         connector->interlace_allowed = false;
2309                         connector->doublescan_allowed = false;
2310                         break;
2311                 }
2312         }
2313
2314         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2315                 if (i2c_bus->valid) {
2316                         connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2317                                             DRM_CONNECTOR_POLL_DISCONNECT;
2318                 }
2319         } else
2320                 connector->polled = DRM_CONNECTOR_POLL_HPD;
2321
2322         connector->display_info.subpixel_order = subpixel_order;
2323         drm_connector_register(connector);
2324
2325         if (has_aux)
2326                 radeon_dp_aux_init(radeon_connector);
2327
2328         return;
2329
2330 failed:
2331         drm_connector_cleanup(connector);
2332         kfree(connector);
2333 }
2334
2335 void
2336 radeon_add_legacy_connector(struct drm_device *dev,
2337                             uint32_t connector_id,
2338                             uint32_t supported_device,
2339                             int connector_type,
2340                             struct radeon_i2c_bus_rec *i2c_bus,
2341                             uint16_t connector_object_id,
2342                             struct radeon_hpd *hpd)
2343 {
2344         struct radeon_device *rdev = dev->dev_private;
2345         struct drm_connector *connector;
2346         struct radeon_connector *radeon_connector;
2347         uint32_t subpixel_order = SubPixelNone;
2348
2349         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
2350                 return;
2351
2352         /* if the user selected tv=0 don't try and add the connector */
2353         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
2354              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
2355              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
2356             (radeon_tv == 0))
2357                 return;
2358
2359         /* see if we already added it */
2360         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2361                 radeon_connector = to_radeon_connector(connector);
2362                 if (radeon_connector->connector_id == connector_id) {
2363                         radeon_connector->devices |= supported_device;
2364                         return;
2365                 }
2366         }
2367
2368         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
2369         if (!radeon_connector)
2370                 return;
2371
2372         connector = &radeon_connector->base;
2373
2374         radeon_connector->connector_id = connector_id;
2375         radeon_connector->devices = supported_device;
2376         radeon_connector->connector_object_id = connector_object_id;
2377         radeon_connector->hpd = *hpd;
2378
2379         switch (connector_type) {
2380         case DRM_MODE_CONNECTOR_VGA:
2381                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2382                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2383                 if (i2c_bus->valid) {
2384                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2385                         if (!radeon_connector->ddc_bus)
2386                                 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2387                 }
2388                 radeon_connector->dac_load_detect = true;
2389                 drm_object_attach_property(&radeon_connector->base.base,
2390                                               rdev->mode_info.load_detect_property,
2391                                               1);
2392                 /* no HPD on analog connectors */
2393                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2394                 connector->interlace_allowed = true;
2395                 connector->doublescan_allowed = true;
2396                 break;
2397         case DRM_MODE_CONNECTOR_DVIA:
2398                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2399                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2400                 if (i2c_bus->valid) {
2401                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2402                         if (!radeon_connector->ddc_bus)
2403                                 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2404                 }
2405                 radeon_connector->dac_load_detect = true;
2406                 drm_object_attach_property(&radeon_connector->base.base,
2407                                               rdev->mode_info.load_detect_property,
2408                                               1);
2409                 /* no HPD on analog connectors */
2410                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2411                 connector->interlace_allowed = true;
2412                 connector->doublescan_allowed = true;
2413                 break;
2414         case DRM_MODE_CONNECTOR_DVII:
2415         case DRM_MODE_CONNECTOR_DVID:
2416                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2417                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2418                 if (i2c_bus->valid) {
2419                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2420                         if (!radeon_connector->ddc_bus)
2421                                 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2422                 }
2423                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2424                         radeon_connector->dac_load_detect = true;
2425                         drm_object_attach_property(&radeon_connector->base.base,
2426                                                       rdev->mode_info.load_detect_property,
2427                                                       1);
2428                 }
2429                 subpixel_order = SubPixelHorizontalRGB;
2430                 connector->interlace_allowed = true;
2431                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2432                         connector->doublescan_allowed = true;
2433                 else
2434                         connector->doublescan_allowed = false;
2435                 break;
2436         case DRM_MODE_CONNECTOR_SVIDEO:
2437         case DRM_MODE_CONNECTOR_Composite:
2438         case DRM_MODE_CONNECTOR_9PinDIN:
2439                 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2440                 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2441                 radeon_connector->dac_load_detect = true;
2442                 /* RS400,RC410,RS480 chipset seems to report a lot
2443                  * of false positive on load detect, we haven't yet
2444                  * found a way to make load detect reliable on those
2445                  * chipset, thus just disable it for TV.
2446                  */
2447                 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
2448                         radeon_connector->dac_load_detect = false;
2449                 drm_object_attach_property(&radeon_connector->base.base,
2450                                               rdev->mode_info.load_detect_property,
2451                                               radeon_connector->dac_load_detect);
2452                 drm_object_attach_property(&radeon_connector->base.base,
2453                                               rdev->mode_info.tv_std_property,
2454                                               radeon_combios_get_tv_info(rdev));
2455                 /* no HPD on analog connectors */
2456                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2457                 connector->interlace_allowed = false;
2458                 connector->doublescan_allowed = false;
2459                 break;
2460         case DRM_MODE_CONNECTOR_LVDS:
2461                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2462                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2463                 if (i2c_bus->valid) {
2464                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2465                         if (!radeon_connector->ddc_bus)
2466                                 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2467                 }
2468                 drm_object_attach_property(&radeon_connector->base.base,
2469                                               dev->mode_config.scaling_mode_property,
2470                                               DRM_MODE_SCALE_FULLSCREEN);
2471                 subpixel_order = SubPixelHorizontalRGB;
2472                 connector->interlace_allowed = false;
2473                 connector->doublescan_allowed = false;
2474                 break;
2475         }
2476
2477         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2478                 if (i2c_bus->valid) {
2479                         connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2480                                             DRM_CONNECTOR_POLL_DISCONNECT;
2481                 }
2482         } else
2483                 connector->polled = DRM_CONNECTOR_POLL_HPD;
2484
2485         connector->display_info.subpixel_order = subpixel_order;
2486         drm_connector_register(connector);
2487 }
2488
2489 void radeon_setup_mst_connector(struct drm_device *dev)
2490 {
2491         struct radeon_device *rdev = dev->dev_private;
2492         struct drm_connector *connector;
2493         struct radeon_connector *radeon_connector;
2494
2495         if (!ASIC_IS_DCE5(rdev))
2496                 return;
2497
2498         if (radeon_mst == 0)
2499                 return;
2500
2501         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2502                 int ret;
2503
2504                 radeon_connector = to_radeon_connector(connector);
2505
2506                 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
2507                         continue;
2508
2509                 ret = radeon_dp_mst_init(radeon_connector);
2510         }
2511 }