Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
radeon_connectors.c
Go to the documentation of this file.
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 #include <drm/drmP.h>
27 #include <drm/drm_edid.h>
28 #include <drm/drm_crtc_helper.h>
29 #include <drm/drm_fb_helper.h>
30 #include <drm/radeon_drm.h>
31 #include "radeon.h"
32 #include "atom.h"
33 
34 extern void
35 radeon_combios_connected_scratch_regs(struct drm_connector *connector,
36  struct drm_encoder *encoder,
37  bool connected);
38 extern void
39 radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
40  struct drm_encoder *encoder,
41  bool connected);
42 
43 void radeon_connector_hotplug(struct drm_connector *connector)
44 {
45  struct drm_device *dev = connector->dev;
46  struct radeon_device *rdev = dev->dev_private;
47  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
48 
49  /* bail if the connector does not have hpd pin, e.g.,
50  * VGA, TV, etc.
51  */
52  if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
53  return;
54 
55  radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
56 
57  /* if the connector is already off, don't turn it back on */
58  if (connector->dpms != DRM_MODE_DPMS_ON)
59  return;
60 
61  /* just deal with DP (not eDP) here. */
62  if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
63  struct radeon_connector_atom_dig *dig_connector =
64  radeon_connector->con_priv;
65 
66  /* if existing sink type was not DP no need to retrain */
67  if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
68  return;
69 
70  /* first get sink type as it may be reset after (un)plug */
71  dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
72  /* don't do anything if sink is not display port, i.e.,
73  * passive dp->(dvi|hdmi) adaptor
74  */
75  if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
76  int saved_dpms = connector->dpms;
77  /* Only turn off the display if it's physically disconnected */
78  if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
79  drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
80  } else if (radeon_dp_needs_link_train(radeon_connector)) {
81  /* set it to OFF so that drm_helper_connector_dpms()
82  * won't return immediately since the current state
83  * is ON at this point.
84  */
85  connector->dpms = DRM_MODE_DPMS_OFF;
86  drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
87  }
88  connector->dpms = saved_dpms;
89  }
90  }
91 }
92 
93 static void radeon_property_change_mode(struct drm_encoder *encoder)
94 {
95  struct drm_crtc *crtc = encoder->crtc;
96 
97  if (crtc && crtc->enabled) {
98  drm_crtc_helper_set_mode(crtc, &crtc->mode,
99  crtc->x, crtc->y, crtc->fb);
100  }
101 }
102 
103 int radeon_get_monitor_bpc(struct drm_connector *connector)
104 {
105  struct drm_device *dev = connector->dev;
106  struct radeon_device *rdev = dev->dev_private;
107  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
108  struct radeon_connector_atom_dig *dig_connector;
109  int bpc = 8;
110 
111  switch (connector->connector_type) {
112  case DRM_MODE_CONNECTOR_DVII:
113  case DRM_MODE_CONNECTOR_HDMIB:
114  if (radeon_connector->use_digital) {
115  if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
116  if (connector->display_info.bpc)
117  bpc = connector->display_info.bpc;
118  }
119  }
120  break;
121  case DRM_MODE_CONNECTOR_DVID:
122  case DRM_MODE_CONNECTOR_HDMIA:
123  if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
124  if (connector->display_info.bpc)
125  bpc = connector->display_info.bpc;
126  }
127  break;
128  case DRM_MODE_CONNECTOR_DisplayPort:
129  dig_connector = radeon_connector->con_priv;
130  if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
131  (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
132  drm_detect_hdmi_monitor(radeon_connector->edid)) {
133  if (connector->display_info.bpc)
134  bpc = connector->display_info.bpc;
135  }
136  break;
137  case DRM_MODE_CONNECTOR_eDP:
138  case DRM_MODE_CONNECTOR_LVDS:
139  if (connector->display_info.bpc)
140  bpc = connector->display_info.bpc;
141  else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
142  struct drm_connector_helper_funcs *connector_funcs =
143  connector->helper_private;
144  struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
145  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
146  struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
147 
148  if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
149  bpc = 6;
150  else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
151  bpc = 8;
152  }
153  break;
154  }
155  return bpc;
156 }
157 
158 static void
159 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
160 {
161  struct drm_device *dev = connector->dev;
162  struct radeon_device *rdev = dev->dev_private;
163  struct drm_encoder *best_encoder = NULL;
164  struct drm_encoder *encoder = NULL;
165  struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
166  struct drm_mode_object *obj;
167  bool connected;
168  int i;
169 
170  best_encoder = connector_funcs->best_encoder(connector);
171 
172  for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
173  if (connector->encoder_ids[i] == 0)
174  break;
175 
176  obj = drm_mode_object_find(connector->dev,
177  connector->encoder_ids[i],
178  DRM_MODE_OBJECT_ENCODER);
179  if (!obj)
180  continue;
181 
182  encoder = obj_to_encoder(obj);
183 
184  if ((encoder == best_encoder) && (status == connector_status_connected))
185  connected = true;
186  else
187  connected = false;
188 
189  if (rdev->is_atom_bios)
190  radeon_atombios_connected_scratch_regs(connector, encoder, connected);
191  else
192  radeon_combios_connected_scratch_regs(connector, encoder, connected);
193 
194  }
195 }
196 
197 static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
198 {
199  struct drm_mode_object *obj;
200  struct drm_encoder *encoder;
201  int i;
202 
203  for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
204  if (connector->encoder_ids[i] == 0)
205  break;
206 
207  obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
208  if (!obj)
209  continue;
210 
211  encoder = obj_to_encoder(obj);
212  if (encoder->encoder_type == encoder_type)
213  return encoder;
214  }
215  return NULL;
216 }
217 
218 static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
219 {
220  int enc_id = connector->encoder_ids[0];
221  struct drm_mode_object *obj;
222  struct drm_encoder *encoder;
223 
224  /* pick the encoder ids */
225  if (enc_id) {
226  obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
227  if (!obj)
228  return NULL;
229  encoder = obj_to_encoder(obj);
230  return encoder;
231  }
232  return NULL;
233 }
234 
235 /*
236  * radeon_connector_analog_encoder_conflict_solve
237  * - search for other connectors sharing this encoder
238  * if priority is true, then set them disconnected if this is connected
239  * if priority is false, set us disconnected if they are connected
240  */
241 static enum drm_connector_status
242 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
243  struct drm_encoder *encoder,
244  enum drm_connector_status current_status,
245  bool priority)
246 {
247  struct drm_device *dev = connector->dev;
248  struct drm_connector *conflict;
249  struct radeon_connector *radeon_conflict;
250  int i;
251 
252  list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
253  if (conflict == connector)
254  continue;
255 
256  radeon_conflict = to_radeon_connector(conflict);
257  for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
258  if (conflict->encoder_ids[i] == 0)
259  break;
260 
261  /* if the IDs match */
262  if (conflict->encoder_ids[i] == encoder->base.id) {
263  if (conflict->status != connector_status_connected)
264  continue;
265 
266  if (radeon_conflict->use_digital)
267  continue;
268 
269  if (priority == true) {
270  DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
271  DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector));
272  conflict->status = connector_status_disconnected;
273  radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
274  } else {
275  DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
276  DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict));
277  current_status = connector_status_disconnected;
278  }
279  break;
280  }
281  }
282  }
283  return current_status;
284 
285 }
286 
287 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
288 {
289  struct drm_device *dev = encoder->dev;
290  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
291  struct drm_display_mode *mode = NULL;
292  struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
293 
294  if (native_mode->hdisplay != 0 &&
295  native_mode->vdisplay != 0 &&
296  native_mode->clock != 0) {
297  mode = drm_mode_duplicate(dev, native_mode);
298  mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
299  drm_mode_set_name(mode);
300 
301  DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
302  } else if (native_mode->hdisplay != 0 &&
303  native_mode->vdisplay != 0) {
304  /* mac laptops without an edid */
305  /* Note that this is not necessarily the exact panel mode,
306  * but an approximation based on the cvt formula. For these
307  * systems we should ideally read the mode info out of the
308  * registers or add a mode table, but this works and is much
309  * simpler.
310  */
311  mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
312  mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
313  DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
314  }
315  return mode;
316 }
317 
318 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
319 {
320  struct drm_device *dev = encoder->dev;
321  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
322  struct drm_display_mode *mode = NULL;
323  struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
324  int i;
325  struct mode_size {
326  int w;
327  int h;
328  } common_modes[17] = {
329  { 640, 480},
330  { 720, 480},
331  { 800, 600},
332  { 848, 480},
333  {1024, 768},
334  {1152, 768},
335  {1280, 720},
336  {1280, 800},
337  {1280, 854},
338  {1280, 960},
339  {1280, 1024},
340  {1440, 900},
341  {1400, 1050},
342  {1680, 1050},
343  {1600, 1200},
344  {1920, 1080},
345  {1920, 1200}
346  };
347 
348  for (i = 0; i < 17; i++) {
349  if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
350  if (common_modes[i].w > 1024 ||
351  common_modes[i].h > 768)
352  continue;
353  }
354  if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
355  if (common_modes[i].w > native_mode->hdisplay ||
356  common_modes[i].h > native_mode->vdisplay ||
357  (common_modes[i].w == native_mode->hdisplay &&
358  common_modes[i].h == native_mode->vdisplay))
359  continue;
360  }
361  if (common_modes[i].w < 320 || common_modes[i].h < 200)
362  continue;
363 
364  mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
365  drm_mode_probed_add(connector, mode);
366  }
367 }
368 
369 static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
370  uint64_t val)
371 {
372  struct drm_device *dev = connector->dev;
373  struct radeon_device *rdev = dev->dev_private;
374  struct drm_encoder *encoder;
375  struct radeon_encoder *radeon_encoder;
376 
377  if (property == rdev->mode_info.coherent_mode_property) {
378  struct radeon_encoder_atom_dig *dig;
379  bool new_coherent_mode;
380 
381  /* need to find digital encoder on connector */
382  encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
383  if (!encoder)
384  return 0;
385 
386  radeon_encoder = to_radeon_encoder(encoder);
387 
388  if (!radeon_encoder->enc_priv)
389  return 0;
390 
391  dig = radeon_encoder->enc_priv;
392  new_coherent_mode = val ? true : false;
393  if (dig->coherent_mode != new_coherent_mode) {
394  dig->coherent_mode = new_coherent_mode;
395  radeon_property_change_mode(&radeon_encoder->base);
396  }
397  }
398 
399  if (property == rdev->mode_info.underscan_property) {
400  /* need to find digital encoder on connector */
401  encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
402  if (!encoder)
403  return 0;
404 
405  radeon_encoder = to_radeon_encoder(encoder);
406 
407  if (radeon_encoder->underscan_type != val) {
408  radeon_encoder->underscan_type = val;
409  radeon_property_change_mode(&radeon_encoder->base);
410  }
411  }
412 
413  if (property == rdev->mode_info.underscan_hborder_property) {
414  /* need to find digital encoder on connector */
415  encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
416  if (!encoder)
417  return 0;
418 
419  radeon_encoder = to_radeon_encoder(encoder);
420 
421  if (radeon_encoder->underscan_hborder != val) {
422  radeon_encoder->underscan_hborder = val;
423  radeon_property_change_mode(&radeon_encoder->base);
424  }
425  }
426 
427  if (property == rdev->mode_info.underscan_vborder_property) {
428  /* need to find digital encoder on connector */
429  encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
430  if (!encoder)
431  return 0;
432 
433  radeon_encoder = to_radeon_encoder(encoder);
434 
435  if (radeon_encoder->underscan_vborder != val) {
436  radeon_encoder->underscan_vborder = val;
437  radeon_property_change_mode(&radeon_encoder->base);
438  }
439  }
440 
441  if (property == rdev->mode_info.tv_std_property) {
442  encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
443  if (!encoder) {
444  encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
445  }
446 
447  if (!encoder)
448  return 0;
449 
450  radeon_encoder = to_radeon_encoder(encoder);
451  if (!radeon_encoder->enc_priv)
452  return 0;
453  if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
454  struct radeon_encoder_atom_dac *dac_int;
455  dac_int = radeon_encoder->enc_priv;
456  dac_int->tv_std = val;
457  } else {
458  struct radeon_encoder_tv_dac *dac_int;
459  dac_int = radeon_encoder->enc_priv;
460  dac_int->tv_std = val;
461  }
462  radeon_property_change_mode(&radeon_encoder->base);
463  }
464 
465  if (property == rdev->mode_info.load_detect_property) {
466  struct radeon_connector *radeon_connector =
467  to_radeon_connector(connector);
468 
469  if (val == 0)
470  radeon_connector->dac_load_detect = false;
471  else
472  radeon_connector->dac_load_detect = true;
473  }
474 
475  if (property == rdev->mode_info.tmds_pll_property) {
476  struct radeon_encoder_int_tmds *tmds = NULL;
477  bool ret = false;
478  /* need to find digital encoder on connector */
479  encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
480  if (!encoder)
481  return 0;
482 
483  radeon_encoder = to_radeon_encoder(encoder);
484 
485  tmds = radeon_encoder->enc_priv;
486  if (!tmds)
487  return 0;
488 
489  if (val == 0) {
490  if (rdev->is_atom_bios)
491  ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
492  else
493  ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
494  }
495  if (val == 1 || ret == false) {
496  radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
497  }
498  radeon_property_change_mode(&radeon_encoder->base);
499  }
500 
501  return 0;
502 }
503 
504 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
505  struct drm_connector *connector)
506 {
507  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
508  struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
509  struct drm_display_mode *t, *mode;
510 
511  /* If the EDID preferred mode doesn't match the native mode, use it */
512  list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
513  if (mode->type & DRM_MODE_TYPE_PREFERRED) {
514  if (mode->hdisplay != native_mode->hdisplay ||
515  mode->vdisplay != native_mode->vdisplay)
516  memcpy(native_mode, mode, sizeof(*mode));
517  }
518  }
519 
520  /* Try to get native mode details from EDID if necessary */
521  if (!native_mode->clock) {
522  list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
523  if (mode->hdisplay == native_mode->hdisplay &&
524  mode->vdisplay == native_mode->vdisplay) {
525  *native_mode = *mode;
526  drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
527  DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
528  break;
529  }
530  }
531  }
532 
533  if (!native_mode->clock) {
534  DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
535  radeon_encoder->rmx_type = RMX_OFF;
536  }
537 }
538 
539 static int radeon_lvds_get_modes(struct drm_connector *connector)
540 {
541  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
542  struct drm_encoder *encoder;
543  int ret = 0;
544  struct drm_display_mode *mode;
545 
546  if (radeon_connector->ddc_bus) {
547  ret = radeon_ddc_get_modes(radeon_connector);
548  if (ret > 0) {
549  encoder = radeon_best_single_encoder(connector);
550  if (encoder) {
551  radeon_fixup_lvds_native_mode(encoder, connector);
552  /* add scaled modes */
553  radeon_add_common_modes(encoder, connector);
554  }
555  return ret;
556  }
557  }
558 
559  encoder = radeon_best_single_encoder(connector);
560  if (!encoder)
561  return 0;
562 
563  /* we have no EDID modes */
564  mode = radeon_fp_native_mode(encoder);
565  if (mode) {
566  ret = 1;
567  drm_mode_probed_add(connector, mode);
568  /* add the width/height from vbios tables if available */
569  connector->display_info.width_mm = mode->width_mm;
570  connector->display_info.height_mm = mode->height_mm;
571  /* add scaled modes */
572  radeon_add_common_modes(encoder, connector);
573  }
574 
575  return ret;
576 }
577 
578 static int radeon_lvds_mode_valid(struct drm_connector *connector,
579  struct drm_display_mode *mode)
580 {
581  struct drm_encoder *encoder = radeon_best_single_encoder(connector);
582 
583  if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
584  return MODE_PANEL;
585 
586  if (encoder) {
587  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
588  struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
589 
590  /* AVIVO hardware supports downscaling modes larger than the panel
591  * to the panel size, but I'm not sure this is desirable.
592  */
593  if ((mode->hdisplay > native_mode->hdisplay) ||
594  (mode->vdisplay > native_mode->vdisplay))
595  return MODE_PANEL;
596 
597  /* if scaling is disabled, block non-native modes */
598  if (radeon_encoder->rmx_type == RMX_OFF) {
599  if ((mode->hdisplay != native_mode->hdisplay) ||
600  (mode->vdisplay != native_mode->vdisplay))
601  return MODE_PANEL;
602  }
603  }
604 
605  return MODE_OK;
606 }
607 
608 static enum drm_connector_status
609 radeon_lvds_detect(struct drm_connector *connector, bool force)
610 {
611  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
612  struct drm_encoder *encoder = radeon_best_single_encoder(connector);
613  enum drm_connector_status ret = connector_status_disconnected;
614 
615  if (encoder) {
616  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
617  struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
618 
619  /* check if panel is valid */
620  if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
621  ret = connector_status_connected;
622 
623  }
624 
625  /* check for edid as well */
626  if (radeon_connector->edid)
627  ret = connector_status_connected;
628  else {
629  if (radeon_connector->ddc_bus) {
630  radeon_connector->edid = drm_get_edid(&radeon_connector->base,
631  &radeon_connector->ddc_bus->adapter);
632  if (radeon_connector->edid)
633  ret = connector_status_connected;
634  }
635  }
636  /* check acpi lid status ??? */
637 
638  radeon_connector_update_scratch_regs(connector, ret);
639  return ret;
640 }
641 
642 static void radeon_connector_destroy(struct drm_connector *connector)
643 {
644  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
645 
646  if (radeon_connector->edid)
647  kfree(radeon_connector->edid);
648  kfree(radeon_connector->con_priv);
649  drm_sysfs_connector_remove(connector);
650  drm_connector_cleanup(connector);
651  kfree(connector);
652 }
653 
654 static int radeon_lvds_set_property(struct drm_connector *connector,
655  struct drm_property *property,
656  uint64_t value)
657 {
658  struct drm_device *dev = connector->dev;
659  struct radeon_encoder *radeon_encoder;
660  enum radeon_rmx_type rmx_type;
661 
662  DRM_DEBUG_KMS("\n");
663  if (property != dev->mode_config.scaling_mode_property)
664  return 0;
665 
666  if (connector->encoder)
667  radeon_encoder = to_radeon_encoder(connector->encoder);
668  else {
669  struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
670  radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
671  }
672 
673  switch (value) {
674  case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
675  case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
676  case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
677  default:
678  case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
679  }
680  if (radeon_encoder->rmx_type == rmx_type)
681  return 0;
682 
683  radeon_encoder->rmx_type = rmx_type;
684 
685  radeon_property_change_mode(&radeon_encoder->base);
686  return 0;
687 }
688 
689 
690 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
691  .get_modes = radeon_lvds_get_modes,
692  .mode_valid = radeon_lvds_mode_valid,
693  .best_encoder = radeon_best_single_encoder,
694 };
695 
696 static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
697  .dpms = drm_helper_connector_dpms,
698  .detect = radeon_lvds_detect,
699  .fill_modes = drm_helper_probe_single_connector_modes,
700  .destroy = radeon_connector_destroy,
701  .set_property = radeon_lvds_set_property,
702 };
703 
704 static int radeon_vga_get_modes(struct drm_connector *connector)
705 {
706  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
707  int ret;
708 
709  ret = radeon_ddc_get_modes(radeon_connector);
710 
711  return ret;
712 }
713 
714 static int radeon_vga_mode_valid(struct drm_connector *connector,
715  struct drm_display_mode *mode)
716 {
717  struct drm_device *dev = connector->dev;
718  struct radeon_device *rdev = dev->dev_private;
719 
720  /* XXX check mode bandwidth */
721 
722  if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
723  return MODE_CLOCK_HIGH;
724 
725  return MODE_OK;
726 }
727 
728 static enum drm_connector_status
729 radeon_vga_detect(struct drm_connector *connector, bool force)
730 {
731  struct drm_device *dev = connector->dev;
732  struct radeon_device *rdev = dev->dev_private;
733  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
734  struct drm_encoder *encoder;
735  struct drm_encoder_helper_funcs *encoder_funcs;
736  bool dret = false;
737  enum drm_connector_status ret = connector_status_disconnected;
738 
739  encoder = radeon_best_single_encoder(connector);
740  if (!encoder)
741  ret = connector_status_disconnected;
742 
743  if (radeon_connector->ddc_bus)
744  dret = radeon_ddc_probe(radeon_connector);
745  if (dret) {
746  radeon_connector->detected_by_load = false;
747  if (radeon_connector->edid) {
748  kfree(radeon_connector->edid);
749  radeon_connector->edid = NULL;
750  }
751  radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
752 
753  if (!radeon_connector->edid) {
754  DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
755  drm_get_connector_name(connector));
756  ret = connector_status_connected;
757  } else {
758  radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
759 
760  /* some oems have boards with separate digital and analog connectors
761  * with a shared ddc line (often vga + hdmi)
762  */
763  if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
764  kfree(radeon_connector->edid);
765  radeon_connector->edid = NULL;
766  ret = connector_status_disconnected;
767  } else
768  ret = connector_status_connected;
769  }
770  } else {
771 
772  /* if we aren't forcing don't do destructive polling */
773  if (!force) {
774  /* only return the previous status if we last
775  * detected a monitor via load.
776  */
777  if (radeon_connector->detected_by_load)
778  return connector->status;
779  else
780  return ret;
781  }
782 
783  if (radeon_connector->dac_load_detect && encoder) {
784  encoder_funcs = encoder->helper_private;
785  ret = encoder_funcs->detect(encoder, connector);
786  if (ret != connector_status_disconnected)
787  radeon_connector->detected_by_load = true;
788  }
789  }
790 
791  if (ret == connector_status_connected)
792  ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
793 
794  /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
795  * vbios to deal with KVMs. If we have one and are not able to detect a monitor
796  * by other means, assume the CRT is connected and use that EDID.
797  */
798  if ((!rdev->is_atom_bios) &&
799  (ret == connector_status_disconnected) &&
800  rdev->mode_info.bios_hardcoded_edid_size) {
801  ret = connector_status_connected;
802  }
803 
804  radeon_connector_update_scratch_regs(connector, ret);
805  return ret;
806 }
807 
808 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
809  .get_modes = radeon_vga_get_modes,
810  .mode_valid = radeon_vga_mode_valid,
811  .best_encoder = radeon_best_single_encoder,
812 };
813 
814 static const struct drm_connector_funcs radeon_vga_connector_funcs = {
815  .dpms = drm_helper_connector_dpms,
816  .detect = radeon_vga_detect,
817  .fill_modes = drm_helper_probe_single_connector_modes,
818  .destroy = radeon_connector_destroy,
819  .set_property = radeon_connector_set_property,
820 };
821 
822 static int radeon_tv_get_modes(struct drm_connector *connector)
823 {
824  struct drm_device *dev = connector->dev;
825  struct radeon_device *rdev = dev->dev_private;
826  struct drm_display_mode *tv_mode;
827  struct drm_encoder *encoder;
828 
829  encoder = radeon_best_single_encoder(connector);
830  if (!encoder)
831  return 0;
832 
833  /* avivo chips can scale any mode */
834  if (rdev->family >= CHIP_RS600)
835  /* add scaled modes */
836  radeon_add_common_modes(encoder, connector);
837  else {
838  /* only 800x600 is supported right now on pre-avivo chips */
839  tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
840  tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
841  drm_mode_probed_add(connector, tv_mode);
842  }
843  return 1;
844 }
845 
846 static int radeon_tv_mode_valid(struct drm_connector *connector,
847  struct drm_display_mode *mode)
848 {
849  if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
850  return MODE_CLOCK_RANGE;
851  return MODE_OK;
852 }
853 
854 static enum drm_connector_status
855 radeon_tv_detect(struct drm_connector *connector, bool force)
856 {
857  struct drm_encoder *encoder;
858  struct drm_encoder_helper_funcs *encoder_funcs;
859  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
860  enum drm_connector_status ret = connector_status_disconnected;
861 
862  if (!radeon_connector->dac_load_detect)
863  return ret;
864 
865  encoder = radeon_best_single_encoder(connector);
866  if (!encoder)
867  ret = connector_status_disconnected;
868  else {
869  encoder_funcs = encoder->helper_private;
870  ret = encoder_funcs->detect(encoder, connector);
871  }
872  if (ret == connector_status_connected)
873  ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
874  radeon_connector_update_scratch_regs(connector, ret);
875  return ret;
876 }
877 
878 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
879  .get_modes = radeon_tv_get_modes,
880  .mode_valid = radeon_tv_mode_valid,
881  .best_encoder = radeon_best_single_encoder,
882 };
883 
884 static const struct drm_connector_funcs radeon_tv_connector_funcs = {
885  .dpms = drm_helper_connector_dpms,
886  .detect = radeon_tv_detect,
887  .fill_modes = drm_helper_probe_single_connector_modes,
888  .destroy = radeon_connector_destroy,
889  .set_property = radeon_connector_set_property,
890 };
891 
892 static int radeon_dvi_get_modes(struct drm_connector *connector)
893 {
894  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
895  int ret;
896 
897  ret = radeon_ddc_get_modes(radeon_connector);
898  return ret;
899 }
900 
901 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
902 {
903  struct drm_device *dev = connector->dev;
904  struct radeon_device *rdev = dev->dev_private;
905  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
906  enum drm_connector_status status;
907 
908  /* We only trust HPD on R600 and newer ASICS. */
909  if (rdev->family >= CHIP_R600
910  && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
911  if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
912  status = connector_status_connected;
913  else
914  status = connector_status_disconnected;
915  if (connector->status == status)
916  return true;
917  }
918 
919  return false;
920 }
921 
922 /*
923  * DVI is complicated
924  * Do a DDC probe, if DDC probe passes, get the full EDID so
925  * we can do analog/digital monitor detection at this point.
926  * If the monitor is an analog monitor or we got no DDC,
927  * we need to find the DAC encoder object for this connector.
928  * If we got no DDC, we do load detection on the DAC encoder object.
929  * If we got analog DDC or load detection passes on the DAC encoder
930  * we have to check if this analog encoder is shared with anyone else (TV)
931  * if its shared we have to set the other connector to disconnected.
932  */
933 static enum drm_connector_status
934 radeon_dvi_detect(struct drm_connector *connector, bool force)
935 {
936  struct drm_device *dev = connector->dev;
937  struct radeon_device *rdev = dev->dev_private;
938  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
939  struct drm_encoder *encoder = NULL;
940  struct drm_encoder_helper_funcs *encoder_funcs;
941  struct drm_mode_object *obj;
942  int i;
943  enum drm_connector_status ret = connector_status_disconnected;
944  bool dret = false, broken_edid = false;
945 
946  if (!force && radeon_check_hpd_status_unchanged(connector))
947  return connector->status;
948 
949  if (radeon_connector->ddc_bus)
950  dret = radeon_ddc_probe(radeon_connector);
951  if (dret) {
952  radeon_connector->detected_by_load = false;
953  if (radeon_connector->edid) {
954  kfree(radeon_connector->edid);
955  radeon_connector->edid = NULL;
956  }
957  radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
958 
959  if (!radeon_connector->edid) {
960  DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
961  drm_get_connector_name(connector));
962  /* rs690 seems to have a problem with connectors not existing and always
963  * return a block of 0's. If we see this just stop polling on this output */
964  if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) {
965  ret = connector_status_disconnected;
966  DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector));
967  radeon_connector->ddc_bus = NULL;
968  } else {
969  ret = connector_status_connected;
970  broken_edid = true; /* defer use_digital to later */
971  }
972  } else {
973  radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
974 
975  /* some oems have boards with separate digital and analog connectors
976  * with a shared ddc line (often vga + hdmi)
977  */
978  if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
979  kfree(radeon_connector->edid);
980  radeon_connector->edid = NULL;
981  ret = connector_status_disconnected;
982  } else
983  ret = connector_status_connected;
984 
985  /* This gets complicated. We have boards with VGA + HDMI with a
986  * shared DDC line and we have boards with DVI-D + HDMI with a shared
987  * DDC line. The latter is more complex because with DVI<->HDMI adapters
988  * you don't really know what's connected to which port as both are digital.
989  */
990  if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
991  struct drm_connector *list_connector;
992  struct radeon_connector *list_radeon_connector;
993  list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
994  if (connector == list_connector)
995  continue;
996  list_radeon_connector = to_radeon_connector(list_connector);
997  if (list_radeon_connector->shared_ddc &&
998  (list_radeon_connector->ddc_bus->rec.i2c_id ==
999  radeon_connector->ddc_bus->rec.i2c_id)) {
1000  /* cases where both connectors are digital */
1001  if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1002  /* hpd is our only option in this case */
1003  if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1004  kfree(radeon_connector->edid);
1005  radeon_connector->edid = NULL;
1006  ret = connector_status_disconnected;
1007  }
1008  }
1009  }
1010  }
1011  }
1012  }
1013  }
1014 
1015  if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1016  goto out;
1017 
1018  /* DVI-D and HDMI-A are digital only */
1019  if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1020  (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1021  goto out;
1022 
1023  /* if we aren't forcing don't do destructive polling */
1024  if (!force) {
1025  /* only return the previous status if we last
1026  * detected a monitor via load.
1027  */
1028  if (radeon_connector->detected_by_load)
1029  ret = connector->status;
1030  goto out;
1031  }
1032 
1033  /* find analog encoder */
1034  if (radeon_connector->dac_load_detect) {
1035  for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1036  if (connector->encoder_ids[i] == 0)
1037  break;
1038 
1039  obj = drm_mode_object_find(connector->dev,
1040  connector->encoder_ids[i],
1041  DRM_MODE_OBJECT_ENCODER);
1042  if (!obj)
1043  continue;
1044 
1045  encoder = obj_to_encoder(obj);
1046 
1047  if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1048  encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1049  continue;
1050 
1051  encoder_funcs = encoder->helper_private;
1052  if (encoder_funcs->detect) {
1053  if (!broken_edid) {
1054  if (ret != connector_status_connected) {
1055  /* deal with analog monitors without DDC */
1056  ret = encoder_funcs->detect(encoder, connector);
1057  if (ret == connector_status_connected) {
1058  radeon_connector->use_digital = false;
1059  }
1060  if (ret != connector_status_disconnected)
1061  radeon_connector->detected_by_load = true;
1062  }
1063  } else {
1064  enum drm_connector_status lret;
1065  /* assume digital unless load detected otherwise */
1066  radeon_connector->use_digital = true;
1067  lret = encoder_funcs->detect(encoder, connector);
1068  DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
1069  if (lret == connector_status_connected)
1070  radeon_connector->use_digital = false;
1071  }
1072  break;
1073  }
1074  }
1075  }
1076 
1077  if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1078  encoder) {
1079  ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1080  }
1081 
1082  /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1083  * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1084  * by other means, assume the DFP is connected and use that EDID. In most
1085  * cases the DVI port is actually a virtual KVM port connected to the service
1086  * processor.
1087  */
1088 out:
1089  if ((!rdev->is_atom_bios) &&
1090  (ret == connector_status_disconnected) &&
1091  rdev->mode_info.bios_hardcoded_edid_size) {
1092  radeon_connector->use_digital = true;
1093  ret = connector_status_connected;
1094  }
1095 
1096  /* updated in get modes as well since we need to know if it's analog or digital */
1097  radeon_connector_update_scratch_regs(connector, ret);
1098  return ret;
1099 }
1100 
1101 /* okay need to be smart in here about which encoder to pick */
1102 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1103 {
1104  int enc_id = connector->encoder_ids[0];
1105  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1106  struct drm_mode_object *obj;
1107  struct drm_encoder *encoder;
1108  int i;
1109  for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1110  if (connector->encoder_ids[i] == 0)
1111  break;
1112 
1113  obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1114  if (!obj)
1115  continue;
1116 
1117  encoder = obj_to_encoder(obj);
1118 
1119  if (radeon_connector->use_digital == true) {
1120  if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1121  return encoder;
1122  } else {
1123  if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1124  encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1125  return encoder;
1126  }
1127  }
1128 
1129  /* see if we have a default encoder TODO */
1130 
1131  /* then check use digitial */
1132  /* pick the first one */
1133  if (enc_id) {
1134  obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
1135  if (!obj)
1136  return NULL;
1137  encoder = obj_to_encoder(obj);
1138  return encoder;
1139  }
1140  return NULL;
1141 }
1142 
1143 static void radeon_dvi_force(struct drm_connector *connector)
1144 {
1145  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1146  if (connector->force == DRM_FORCE_ON)
1147  radeon_connector->use_digital = false;
1148  if (connector->force == DRM_FORCE_ON_DIGITAL)
1149  radeon_connector->use_digital = true;
1150 }
1151 
1152 static int radeon_dvi_mode_valid(struct drm_connector *connector,
1153  struct drm_display_mode *mode)
1154 {
1155  struct drm_device *dev = connector->dev;
1156  struct radeon_device *rdev = dev->dev_private;
1157  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1158 
1159  /* XXX check mode bandwidth */
1160 
1161  /* clocks over 135 MHz have heat issues with DVI on RV100 */
1162  if (radeon_connector->use_digital &&
1163  (rdev->family == CHIP_RV100) &&
1164  (mode->clock > 135000))
1165  return MODE_CLOCK_HIGH;
1166 
1167  if (radeon_connector->use_digital && (mode->clock > 165000)) {
1168  if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1169  (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1170  (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1171  return MODE_OK;
1172  else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) {
1173  if (ASIC_IS_DCE6(rdev)) {
1174  /* HDMI 1.3+ supports max clock of 340 Mhz */
1175  if (mode->clock > 340000)
1176  return MODE_CLOCK_HIGH;
1177  else
1178  return MODE_OK;
1179  } else
1180  return MODE_CLOCK_HIGH;
1181  } else
1182  return MODE_CLOCK_HIGH;
1183  }
1184 
1185  /* check against the max pixel clock */
1186  if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1187  return MODE_CLOCK_HIGH;
1188 
1189  return MODE_OK;
1190 }
1191 
1192 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1193  .get_modes = radeon_dvi_get_modes,
1194  .mode_valid = radeon_dvi_mode_valid,
1195  .best_encoder = radeon_dvi_encoder,
1196 };
1197 
1198 static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1199  .dpms = drm_helper_connector_dpms,
1200  .detect = radeon_dvi_detect,
1201  .fill_modes = drm_helper_probe_single_connector_modes,
1202  .set_property = radeon_connector_set_property,
1203  .destroy = radeon_connector_destroy,
1204  .force = radeon_dvi_force,
1205 };
1206 
1207 static void radeon_dp_connector_destroy(struct drm_connector *connector)
1208 {
1209  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1210  struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1211 
1212  if (radeon_connector->edid)
1213  kfree(radeon_connector->edid);
1214  if (radeon_dig_connector->dp_i2c_bus)
1215  radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
1216  kfree(radeon_connector->con_priv);
1217  drm_sysfs_connector_remove(connector);
1218  drm_connector_cleanup(connector);
1219  kfree(connector);
1220 }
1221 
1222 static int radeon_dp_get_modes(struct drm_connector *connector)
1223 {
1224  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1225  struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1226  struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1227  int ret;
1228 
1229  if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1230  (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1231  struct drm_display_mode *mode;
1232 
1233  if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1234  if (!radeon_dig_connector->edp_on)
1235  atombios_set_edp_panel_power(connector,
1236  ATOM_TRANSMITTER_ACTION_POWER_ON);
1237  ret = radeon_ddc_get_modes(radeon_connector);
1238  if (!radeon_dig_connector->edp_on)
1239  atombios_set_edp_panel_power(connector,
1240  ATOM_TRANSMITTER_ACTION_POWER_OFF);
1241  } else {
1242  /* need to setup ddc on the bridge */
1243  if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1244  ENCODER_OBJECT_ID_NONE) {
1245  if (encoder)
1246  radeon_atom_ext_encoder_setup_ddc(encoder);
1247  }
1248  ret = radeon_ddc_get_modes(radeon_connector);
1249  }
1250 
1251  if (ret > 0) {
1252  if (encoder) {
1253  radeon_fixup_lvds_native_mode(encoder, connector);
1254  /* add scaled modes */
1255  radeon_add_common_modes(encoder, connector);
1256  }
1257  return ret;
1258  }
1259 
1260  if (!encoder)
1261  return 0;
1262 
1263  /* we have no EDID modes */
1264  mode = radeon_fp_native_mode(encoder);
1265  if (mode) {
1266  ret = 1;
1267  drm_mode_probed_add(connector, mode);
1268  /* add the width/height from vbios tables if available */
1269  connector->display_info.width_mm = mode->width_mm;
1270  connector->display_info.height_mm = mode->height_mm;
1271  /* add scaled modes */
1272  radeon_add_common_modes(encoder, connector);
1273  }
1274  } else {
1275  /* need to setup ddc on the bridge */
1276  if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1277  ENCODER_OBJECT_ID_NONE) {
1278  if (encoder)
1279  radeon_atom_ext_encoder_setup_ddc(encoder);
1280  }
1281  ret = radeon_ddc_get_modes(radeon_connector);
1282  }
1283 
1284  return ret;
1285 }
1286 
1287 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1288 {
1289  struct drm_mode_object *obj;
1290  struct drm_encoder *encoder;
1291  struct radeon_encoder *radeon_encoder;
1292  int i;
1293 
1294  for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1295  if (connector->encoder_ids[i] == 0)
1296  break;
1297 
1298  obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1299  if (!obj)
1300  continue;
1301 
1302  encoder = obj_to_encoder(obj);
1303  radeon_encoder = to_radeon_encoder(encoder);
1304 
1305  switch (radeon_encoder->encoder_id) {
1306  case ENCODER_OBJECT_ID_TRAVIS:
1307  case ENCODER_OBJECT_ID_NUTMEG:
1308  return radeon_encoder->encoder_id;
1309  default:
1310  break;
1311  }
1312  }
1313 
1314  return ENCODER_OBJECT_ID_NONE;
1315 }
1316 
1317 bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1318 {
1319  struct drm_mode_object *obj;
1320  struct drm_encoder *encoder;
1321  struct radeon_encoder *radeon_encoder;
1322  int i;
1323  bool found = false;
1324 
1325  for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1326  if (connector->encoder_ids[i] == 0)
1327  break;
1328 
1329  obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1330  if (!obj)
1331  continue;
1332 
1333  encoder = obj_to_encoder(obj);
1334  radeon_encoder = to_radeon_encoder(encoder);
1335  if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1336  found = true;
1337  }
1338 
1339  return found;
1340 }
1341 
1342 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1343 {
1344  struct drm_device *dev = connector->dev;
1345  struct radeon_device *rdev = dev->dev_private;
1346 
1347  if (ASIC_IS_DCE5(rdev) &&
1348  (rdev->clock.dp_extclk >= 53900) &&
1349  radeon_connector_encoder_is_hbr2(connector)) {
1350  return true;
1351  }
1352 
1353  return false;
1354 }
1355 
1356 static enum drm_connector_status
1357 radeon_dp_detect(struct drm_connector *connector, bool force)
1358 {
1359  struct drm_device *dev = connector->dev;
1360  struct radeon_device *rdev = dev->dev_private;
1361  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1362  enum drm_connector_status ret = connector_status_disconnected;
1363  struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1364  struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1365 
1366  if (!force && radeon_check_hpd_status_unchanged(connector))
1367  return connector->status;
1368 
1369  if (radeon_connector->edid) {
1370  kfree(radeon_connector->edid);
1371  radeon_connector->edid = NULL;
1372  }
1373 
1374  if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1375  (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1376  if (encoder) {
1377  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1378  struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1379 
1380  /* check if panel is valid */
1381  if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1382  ret = connector_status_connected;
1383  }
1384  /* eDP is always DP */
1385  radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1386  if (!radeon_dig_connector->edp_on)
1387  atombios_set_edp_panel_power(connector,
1388  ATOM_TRANSMITTER_ACTION_POWER_ON);
1389  if (radeon_dp_getdpcd(radeon_connector))
1390  ret = connector_status_connected;
1391  if (!radeon_dig_connector->edp_on)
1392  atombios_set_edp_panel_power(connector,
1393  ATOM_TRANSMITTER_ACTION_POWER_OFF);
1394  } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1395  ENCODER_OBJECT_ID_NONE) {
1396  /* DP bridges are always DP */
1397  radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1398  /* get the DPCD from the bridge */
1399  radeon_dp_getdpcd(radeon_connector);
1400 
1401  if (encoder) {
1402  /* setup ddc on the bridge */
1403  radeon_atom_ext_encoder_setup_ddc(encoder);
1404  if (radeon_ddc_probe(radeon_connector)) /* try DDC */
1405  ret = connector_status_connected;
1406  else if (radeon_connector->dac_load_detect) { /* try load detection */
1407  struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1408  ret = encoder_funcs->detect(encoder, connector);
1409  }
1410  }
1411  } else {
1412  radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1413  if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1414  ret = connector_status_connected;
1415  if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
1416  radeon_dp_getdpcd(radeon_connector);
1417  } else {
1418  if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1419  if (radeon_dp_getdpcd(radeon_connector))
1420  ret = connector_status_connected;
1421  } else {
1422  if (radeon_ddc_probe(radeon_connector))
1423  ret = connector_status_connected;
1424  }
1425  }
1426  }
1427 
1428  radeon_connector_update_scratch_regs(connector, ret);
1429  return ret;
1430 }
1431 
1432 static int radeon_dp_mode_valid(struct drm_connector *connector,
1433  struct drm_display_mode *mode)
1434 {
1435  struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1436  struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1437 
1438  /* XXX check mode bandwidth */
1439 
1440  if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1441  (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1442  struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1443 
1444  if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1445  return MODE_PANEL;
1446 
1447  if (encoder) {
1448  struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1449  struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1450 
1451  /* AVIVO hardware supports downscaling modes larger than the panel
1452  * to the panel size, but I'm not sure this is desirable.
1453  */
1454  if ((mode->hdisplay > native_mode->hdisplay) ||
1455  (mode->vdisplay > native_mode->vdisplay))
1456  return MODE_PANEL;
1457 
1458  /* if scaling is disabled, block non-native modes */
1459  if (radeon_encoder->rmx_type == RMX_OFF) {
1460  if ((mode->hdisplay != native_mode->hdisplay) ||
1461  (mode->vdisplay != native_mode->vdisplay))
1462  return MODE_PANEL;
1463  }
1464  }
1465  return MODE_OK;
1466  } else {
1467  if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1468  (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1469  return radeon_dp_mode_valid_helper(connector, mode);
1470  else
1471  return MODE_OK;
1472  }
1473 }
1474 
1475 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1476  .get_modes = radeon_dp_get_modes,
1477  .mode_valid = radeon_dp_mode_valid,
1478  .best_encoder = radeon_dvi_encoder,
1479 };
1480 
1481 static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1482  .dpms = drm_helper_connector_dpms,
1483  .detect = radeon_dp_detect,
1484  .fill_modes = drm_helper_probe_single_connector_modes,
1485  .set_property = radeon_connector_set_property,
1486  .destroy = radeon_dp_connector_destroy,
1487  .force = radeon_dvi_force,
1488 };
1489 
1490 void
1491 radeon_add_atom_connector(struct drm_device *dev,
1492  uint32_t connector_id,
1493  uint32_t supported_device,
1494  int connector_type,
1495  struct radeon_i2c_bus_rec *i2c_bus,
1496  uint32_t igp_lane_info,
1497  uint16_t connector_object_id,
1498  struct radeon_hpd *hpd,
1499  struct radeon_router *router)
1500 {
1501  struct radeon_device *rdev = dev->dev_private;
1502  struct drm_connector *connector;
1503  struct radeon_connector *radeon_connector;
1504  struct radeon_connector_atom_dig *radeon_dig_connector;
1505  struct drm_encoder *encoder;
1506  struct radeon_encoder *radeon_encoder;
1507  uint32_t subpixel_order = SubPixelNone;
1508  bool shared_ddc = false;
1509  bool is_dp_bridge = false;
1510 
1511  if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1512  return;
1513 
1514  /* if the user selected tv=0 don't try and add the connector */
1515  if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1516  (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1517  (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1518  (radeon_tv == 0))
1519  return;
1520 
1521  /* see if we already added it */
1522  list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1523  radeon_connector = to_radeon_connector(connector);
1524  if (radeon_connector->connector_id == connector_id) {
1525  radeon_connector->devices |= supported_device;
1526  return;
1527  }
1528  if (radeon_connector->ddc_bus && i2c_bus->valid) {
1529  if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1530  radeon_connector->shared_ddc = true;
1531  shared_ddc = true;
1532  }
1533  if (radeon_connector->router_bus && router->ddc_valid &&
1534  (radeon_connector->router.router_id == router->router_id)) {
1535  radeon_connector->shared_ddc = false;
1536  shared_ddc = false;
1537  }
1538  }
1539  }
1540 
1541  /* check if it's a dp bridge */
1542  list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1543  radeon_encoder = to_radeon_encoder(encoder);
1544  if (radeon_encoder->devices & supported_device) {
1545  switch (radeon_encoder->encoder_id) {
1546  case ENCODER_OBJECT_ID_TRAVIS:
1547  case ENCODER_OBJECT_ID_NUTMEG:
1548  is_dp_bridge = true;
1549  break;
1550  default:
1551  break;
1552  }
1553  }
1554  }
1555 
1556  radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1557  if (!radeon_connector)
1558  return;
1559 
1560  connector = &radeon_connector->base;
1561 
1562  radeon_connector->connector_id = connector_id;
1563  radeon_connector->devices = supported_device;
1564  radeon_connector->shared_ddc = shared_ddc;
1565  radeon_connector->connector_object_id = connector_object_id;
1566  radeon_connector->hpd = *hpd;
1567 
1568  radeon_connector->router = *router;
1569  if (router->ddc_valid || router->cd_valid) {
1570  radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1571  if (!radeon_connector->router_bus)
1572  DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1573  }
1574 
1575  if (is_dp_bridge) {
1576  radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1577  if (!radeon_dig_connector)
1578  goto failed;
1579  radeon_dig_connector->igp_lane_info = igp_lane_info;
1580  radeon_connector->con_priv = radeon_dig_connector;
1581  drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1582  drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1583  if (i2c_bus->valid) {
1584  /* add DP i2c bus */
1585  if (connector_type == DRM_MODE_CONNECTOR_eDP)
1586  radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1587  else
1588  radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1589  if (!radeon_dig_connector->dp_i2c_bus)
1590  DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1591  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1592  if (!radeon_connector->ddc_bus)
1593  DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1594  }
1595  switch (connector_type) {
1596  case DRM_MODE_CONNECTOR_VGA:
1597  case DRM_MODE_CONNECTOR_DVIA:
1598  default:
1599  connector->interlace_allowed = true;
1600  connector->doublescan_allowed = true;
1601  radeon_connector->dac_load_detect = true;
1602  drm_connector_attach_property(&radeon_connector->base,
1603  rdev->mode_info.load_detect_property,
1604  1);
1605  break;
1606  case DRM_MODE_CONNECTOR_DVII:
1607  case DRM_MODE_CONNECTOR_DVID:
1608  case DRM_MODE_CONNECTOR_HDMIA:
1609  case DRM_MODE_CONNECTOR_HDMIB:
1610  case DRM_MODE_CONNECTOR_DisplayPort:
1611  drm_connector_attach_property(&radeon_connector->base,
1612  rdev->mode_info.underscan_property,
1613  UNDERSCAN_OFF);
1614  drm_connector_attach_property(&radeon_connector->base,
1615  rdev->mode_info.underscan_hborder_property,
1616  0);
1617  drm_connector_attach_property(&radeon_connector->base,
1618  rdev->mode_info.underscan_vborder_property,
1619  0);
1620  subpixel_order = SubPixelHorizontalRGB;
1621  connector->interlace_allowed = true;
1622  if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1623  connector->doublescan_allowed = true;
1624  else
1625  connector->doublescan_allowed = false;
1626  if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1627  radeon_connector->dac_load_detect = true;
1628  drm_connector_attach_property(&radeon_connector->base,
1629  rdev->mode_info.load_detect_property,
1630  1);
1631  }
1632  break;
1633  case DRM_MODE_CONNECTOR_LVDS:
1634  case DRM_MODE_CONNECTOR_eDP:
1635  drm_connector_attach_property(&radeon_connector->base,
1636  dev->mode_config.scaling_mode_property,
1637  DRM_MODE_SCALE_FULLSCREEN);
1638  subpixel_order = SubPixelHorizontalRGB;
1639  connector->interlace_allowed = false;
1640  connector->doublescan_allowed = false;
1641  break;
1642  }
1643  } else {
1644  switch (connector_type) {
1645  case DRM_MODE_CONNECTOR_VGA:
1646  drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1647  drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1648  if (i2c_bus->valid) {
1649  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1650  if (!radeon_connector->ddc_bus)
1651  DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1652  }
1653  radeon_connector->dac_load_detect = true;
1654  drm_connector_attach_property(&radeon_connector->base,
1655  rdev->mode_info.load_detect_property,
1656  1);
1657  /* no HPD on analog connectors */
1658  radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1659  connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1660  connector->interlace_allowed = true;
1661  connector->doublescan_allowed = true;
1662  break;
1663  case DRM_MODE_CONNECTOR_DVIA:
1664  drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1665  drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1666  if (i2c_bus->valid) {
1667  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1668  if (!radeon_connector->ddc_bus)
1669  DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1670  }
1671  radeon_connector->dac_load_detect = true;
1672  drm_connector_attach_property(&radeon_connector->base,
1673  rdev->mode_info.load_detect_property,
1674  1);
1675  /* no HPD on analog connectors */
1676  radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1677  connector->interlace_allowed = true;
1678  connector->doublescan_allowed = true;
1679  break;
1680  case DRM_MODE_CONNECTOR_DVII:
1681  case DRM_MODE_CONNECTOR_DVID:
1682  radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1683  if (!radeon_dig_connector)
1684  goto failed;
1685  radeon_dig_connector->igp_lane_info = igp_lane_info;
1686  radeon_connector->con_priv = radeon_dig_connector;
1687  drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1688  drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1689  if (i2c_bus->valid) {
1690  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1691  if (!radeon_connector->ddc_bus)
1692  DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1693  }
1694  subpixel_order = SubPixelHorizontalRGB;
1695  drm_connector_attach_property(&radeon_connector->base,
1696  rdev->mode_info.coherent_mode_property,
1697  1);
1698  if (ASIC_IS_AVIVO(rdev)) {
1699  drm_connector_attach_property(&radeon_connector->base,
1700  rdev->mode_info.underscan_property,
1701  UNDERSCAN_OFF);
1702  drm_connector_attach_property(&radeon_connector->base,
1703  rdev->mode_info.underscan_hborder_property,
1704  0);
1705  drm_connector_attach_property(&radeon_connector->base,
1706  rdev->mode_info.underscan_vborder_property,
1707  0);
1708  }
1709  if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1710  radeon_connector->dac_load_detect = true;
1711  drm_connector_attach_property(&radeon_connector->base,
1712  rdev->mode_info.load_detect_property,
1713  1);
1714  }
1715  connector->interlace_allowed = true;
1716  if (connector_type == DRM_MODE_CONNECTOR_DVII)
1717  connector->doublescan_allowed = true;
1718  else
1719  connector->doublescan_allowed = false;
1720  break;
1721  case DRM_MODE_CONNECTOR_HDMIA:
1722  case DRM_MODE_CONNECTOR_HDMIB:
1723  radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1724  if (!radeon_dig_connector)
1725  goto failed;
1726  radeon_dig_connector->igp_lane_info = igp_lane_info;
1727  radeon_connector->con_priv = radeon_dig_connector;
1728  drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1729  drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1730  if (i2c_bus->valid) {
1731  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1732  if (!radeon_connector->ddc_bus)
1733  DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1734  }
1735  drm_connector_attach_property(&radeon_connector->base,
1736  rdev->mode_info.coherent_mode_property,
1737  1);
1738  if (ASIC_IS_AVIVO(rdev)) {
1739  drm_connector_attach_property(&radeon_connector->base,
1740  rdev->mode_info.underscan_property,
1741  UNDERSCAN_OFF);
1742  drm_connector_attach_property(&radeon_connector->base,
1743  rdev->mode_info.underscan_hborder_property,
1744  0);
1745  drm_connector_attach_property(&radeon_connector->base,
1746  rdev->mode_info.underscan_vborder_property,
1747  0);
1748  }
1749  subpixel_order = SubPixelHorizontalRGB;
1750  connector->interlace_allowed = true;
1751  if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1752  connector->doublescan_allowed = true;
1753  else
1754  connector->doublescan_allowed = false;
1755  break;
1756  case DRM_MODE_CONNECTOR_DisplayPort:
1757  radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1758  if (!radeon_dig_connector)
1759  goto failed;
1760  radeon_dig_connector->igp_lane_info = igp_lane_info;
1761  radeon_connector->con_priv = radeon_dig_connector;
1762  drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1763  drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1764  if (i2c_bus->valid) {
1765  /* add DP i2c bus */
1766  radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1767  if (!radeon_dig_connector->dp_i2c_bus)
1768  DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1769  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1770  if (!radeon_connector->ddc_bus)
1771  DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1772  }
1773  subpixel_order = SubPixelHorizontalRGB;
1774  drm_connector_attach_property(&radeon_connector->base,
1775  rdev->mode_info.coherent_mode_property,
1776  1);
1777  if (ASIC_IS_AVIVO(rdev)) {
1778  drm_connector_attach_property(&radeon_connector->base,
1779  rdev->mode_info.underscan_property,
1780  UNDERSCAN_OFF);
1781  drm_connector_attach_property(&radeon_connector->base,
1782  rdev->mode_info.underscan_hborder_property,
1783  0);
1784  drm_connector_attach_property(&radeon_connector->base,
1785  rdev->mode_info.underscan_vborder_property,
1786  0);
1787  }
1788  connector->interlace_allowed = true;
1789  /* in theory with a DP to VGA converter... */
1790  connector->doublescan_allowed = false;
1791  break;
1792  case DRM_MODE_CONNECTOR_eDP:
1793  radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1794  if (!radeon_dig_connector)
1795  goto failed;
1796  radeon_dig_connector->igp_lane_info = igp_lane_info;
1797  radeon_connector->con_priv = radeon_dig_connector;
1798  drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1799  drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1800  if (i2c_bus->valid) {
1801  /* add DP i2c bus */
1802  radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1803  if (!radeon_dig_connector->dp_i2c_bus)
1804  DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1805  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1806  if (!radeon_connector->ddc_bus)
1807  DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1808  }
1809  drm_connector_attach_property(&radeon_connector->base,
1810  dev->mode_config.scaling_mode_property,
1811  DRM_MODE_SCALE_FULLSCREEN);
1812  subpixel_order = SubPixelHorizontalRGB;
1813  connector->interlace_allowed = false;
1814  connector->doublescan_allowed = false;
1815  break;
1816  case DRM_MODE_CONNECTOR_SVIDEO:
1817  case DRM_MODE_CONNECTOR_Composite:
1818  case DRM_MODE_CONNECTOR_9PinDIN:
1819  drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1820  drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1821  radeon_connector->dac_load_detect = true;
1822  drm_connector_attach_property(&radeon_connector->base,
1823  rdev->mode_info.load_detect_property,
1824  1);
1825  drm_connector_attach_property(&radeon_connector->base,
1826  rdev->mode_info.tv_std_property,
1827  radeon_atombios_get_tv_info(rdev));
1828  /* no HPD on analog connectors */
1829  radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1830  connector->interlace_allowed = false;
1831  connector->doublescan_allowed = false;
1832  break;
1833  case DRM_MODE_CONNECTOR_LVDS:
1834  radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1835  if (!radeon_dig_connector)
1836  goto failed;
1837  radeon_dig_connector->igp_lane_info = igp_lane_info;
1838  radeon_connector->con_priv = radeon_dig_connector;
1839  drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1840  drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1841  if (i2c_bus->valid) {
1842  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1843  if (!radeon_connector->ddc_bus)
1844  DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1845  }
1846  drm_connector_attach_property(&radeon_connector->base,
1847  dev->mode_config.scaling_mode_property,
1848  DRM_MODE_SCALE_FULLSCREEN);
1849  subpixel_order = SubPixelHorizontalRGB;
1850  connector->interlace_allowed = false;
1851  connector->doublescan_allowed = false;
1852  break;
1853  }
1854  }
1855 
1856  if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
1857  if (i2c_bus->valid)
1858  connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1859  } else
1860  connector->polled = DRM_CONNECTOR_POLL_HPD;
1861 
1862  connector->display_info.subpixel_order = subpixel_order;
1863  drm_sysfs_connector_add(connector);
1864  return;
1865 
1866 failed:
1867  drm_connector_cleanup(connector);
1868  kfree(connector);
1869 }
1870 
1871 void
1872 radeon_add_legacy_connector(struct drm_device *dev,
1873  uint32_t connector_id,
1874  uint32_t supported_device,
1875  int connector_type,
1876  struct radeon_i2c_bus_rec *i2c_bus,
1877  uint16_t connector_object_id,
1878  struct radeon_hpd *hpd)
1879 {
1880  struct radeon_device *rdev = dev->dev_private;
1881  struct drm_connector *connector;
1882  struct radeon_connector *radeon_connector;
1883  uint32_t subpixel_order = SubPixelNone;
1884 
1885  if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1886  return;
1887 
1888  /* if the user selected tv=0 don't try and add the connector */
1889  if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1890  (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1891  (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1892  (radeon_tv == 0))
1893  return;
1894 
1895  /* see if we already added it */
1896  list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1897  radeon_connector = to_radeon_connector(connector);
1898  if (radeon_connector->connector_id == connector_id) {
1899  radeon_connector->devices |= supported_device;
1900  return;
1901  }
1902  }
1903 
1904  radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1905  if (!radeon_connector)
1906  return;
1907 
1908  connector = &radeon_connector->base;
1909 
1910  radeon_connector->connector_id = connector_id;
1911  radeon_connector->devices = supported_device;
1912  radeon_connector->connector_object_id = connector_object_id;
1913  radeon_connector->hpd = *hpd;
1914 
1915  switch (connector_type) {
1916  case DRM_MODE_CONNECTOR_VGA:
1917  drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1918  drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1919  if (i2c_bus->valid) {
1920  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1921  if (!radeon_connector->ddc_bus)
1922  DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1923  }
1924  radeon_connector->dac_load_detect = true;
1925  drm_connector_attach_property(&radeon_connector->base,
1926  rdev->mode_info.load_detect_property,
1927  1);
1928  /* no HPD on analog connectors */
1929  radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1930  connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1931  connector->interlace_allowed = true;
1932  connector->doublescan_allowed = true;
1933  break;
1934  case DRM_MODE_CONNECTOR_DVIA:
1935  drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1936  drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1937  if (i2c_bus->valid) {
1938  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1939  if (!radeon_connector->ddc_bus)
1940  DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1941  }
1942  radeon_connector->dac_load_detect = true;
1943  drm_connector_attach_property(&radeon_connector->base,
1944  rdev->mode_info.load_detect_property,
1945  1);
1946  /* no HPD on analog connectors */
1947  radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1948  connector->interlace_allowed = true;
1949  connector->doublescan_allowed = true;
1950  break;
1951  case DRM_MODE_CONNECTOR_DVII:
1952  case DRM_MODE_CONNECTOR_DVID:
1953  drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1954  drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1955  if (i2c_bus->valid) {
1956  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1957  if (!radeon_connector->ddc_bus)
1958  DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1959  }
1960  if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1961  radeon_connector->dac_load_detect = true;
1962  drm_connector_attach_property(&radeon_connector->base,
1963  rdev->mode_info.load_detect_property,
1964  1);
1965  }
1966  subpixel_order = SubPixelHorizontalRGB;
1967  connector->interlace_allowed = true;
1968  if (connector_type == DRM_MODE_CONNECTOR_DVII)
1969  connector->doublescan_allowed = true;
1970  else
1971  connector->doublescan_allowed = false;
1972  break;
1973  case DRM_MODE_CONNECTOR_SVIDEO:
1974  case DRM_MODE_CONNECTOR_Composite:
1975  case DRM_MODE_CONNECTOR_9PinDIN:
1976  drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1977  drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1978  radeon_connector->dac_load_detect = true;
1979  /* RS400,RC410,RS480 chipset seems to report a lot
1980  * of false positive on load detect, we haven't yet
1981  * found a way to make load detect reliable on those
1982  * chipset, thus just disable it for TV.
1983  */
1984  if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1985  radeon_connector->dac_load_detect = false;
1986  drm_connector_attach_property(&radeon_connector->base,
1987  rdev->mode_info.load_detect_property,
1988  radeon_connector->dac_load_detect);
1989  drm_connector_attach_property(&radeon_connector->base,
1990  rdev->mode_info.tv_std_property,
1991  radeon_combios_get_tv_info(rdev));
1992  /* no HPD on analog connectors */
1993  radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1994  connector->interlace_allowed = false;
1995  connector->doublescan_allowed = false;
1996  break;
1997  case DRM_MODE_CONNECTOR_LVDS:
1998  drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1999  drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2000  if (i2c_bus->valid) {
2001  radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2002  if (!radeon_connector->ddc_bus)
2003  DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2004  }
2005  drm_connector_attach_property(&radeon_connector->base,
2006  dev->mode_config.scaling_mode_property,
2007  DRM_MODE_SCALE_FULLSCREEN);
2008  subpixel_order = SubPixelHorizontalRGB;
2009  connector->interlace_allowed = false;
2010  connector->doublescan_allowed = false;
2011  break;
2012  }
2013 
2014  if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2015  if (i2c_bus->valid)
2016  connector->polled = DRM_CONNECTOR_POLL_CONNECT;
2017  } else
2018  connector->polled = DRM_CONNECTOR_POLL_HPD;
2019  connector->display_info.subpixel_order = subpixel_order;
2020  drm_sysfs_connector_add(connector);
2021 }
Generated on Thu Jan 10 2013 13:33:19 for Linux Kernel by   doxygen 1.8.2