projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/radeon/kms: enable r600 tv outputs.
[linux-2.6-block.git] / drivers / gpu / drm / radeon / radeon_connectors.c
CommitLineData
771fe6b9
JG		 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 "drmP.h"
27#include "drm_edid.h"
28#include "drm_crtc_helper.h"
29#include "radeon_drm.h"
30#include "radeon.h"
923f6848 31#include "atom.h"
771fe6b9
JG		 32
33extern void
34radeon_combios_connected_scratch_regs(struct drm_connector *connector,
35 struct drm_encoder *encoder,
36 bool connected);
37extern void
38radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
39 struct drm_encoder *encoder,
40 bool connected);
41
445282db
DA		 42static void radeon_property_change_mode(struct drm_encoder *encoder)
43{
44 struct drm_crtc *crtc = encoder->crtc;
45
46 if (crtc && crtc->enabled) {
47 drm_crtc_helper_set_mode(crtc, &crtc->mode,
48 crtc->x, crtc->y, crtc->fb);
49 }
50}
771fe6b9
JG		 51static void
52radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
53{
54 struct drm_device *dev = connector->dev;
55 struct radeon_device *rdev = dev->dev_private;
56 struct drm_encoder *best_encoder = NULL;
57 struct drm_encoder *encoder = NULL;
58 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
59 struct drm_mode_object *obj;
60 bool connected;
61 int i;
62
63 best_encoder = connector_funcs->best_encoder(connector);
64
65 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
66 if (connector->encoder_ids[i] == 0)
67 break;
68
69 obj = drm_mode_object_find(connector->dev,
70 connector->encoder_ids[i],
71 DRM_MODE_OBJECT_ENCODER);
72 if (!obj)
73 continue;
74
75 encoder = obj_to_encoder(obj);
76
77 if ((encoder == best_encoder) && (status == connector_status_connected))
78 connected = true;
79 else
80 connected = false;
81
82 if (rdev->is_atom_bios)
83 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
84 else
85 radeon_combios_connected_scratch_regs(connector, encoder, connected);
86
87 }
88}
89
445282db
DA		 90struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
91{
92 struct drm_mode_object *obj;
93 struct drm_encoder *encoder;
94 int i;
95
96 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
97 if (connector->encoder_ids[i] == 0)
98 break;
99
100 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
101 if (!obj)
102 continue;
103
104 encoder = obj_to_encoder(obj);
105 if (encoder->encoder_type == encoder_type)
106 return encoder;
107 }
108 return NULL;
109}
110
771fe6b9
JG		 111struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
112{
113 int enc_id = connector->encoder_ids[0];
114 struct drm_mode_object *obj;
115 struct drm_encoder *encoder;
116
117 /* pick the encoder ids */
118 if (enc_id) {
119 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
120 if (!obj)
121 return NULL;
122 encoder = obj_to_encoder(obj);
123 return encoder;
124 }
125 return NULL;
126}
127
4ce001ab
DA		 128/*
129 * radeon_connector_analog_encoder_conflict_solve
130 * - search for other connectors sharing this encoder
131 * if priority is true, then set them disconnected if this is connected
132 * if priority is false, set us disconnected if they are connected
133 */
134static enum drm_connector_status
135radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
136 struct drm_encoder *encoder,
137 enum drm_connector_status current_status,
138 bool priority)
139{
140 struct drm_device *dev = connector->dev;
141 struct drm_connector *conflict;
142 int i;
143
144 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
145 if (conflict == connector)
146 continue;
147
148 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
149 if (conflict->encoder_ids[i] == 0)
150 break;
151
152 /* if the IDs match */
153 if (conflict->encoder_ids[i] == encoder->base.id) {
154 if (conflict->status != connector_status_connected)
155 continue;
156
157 if (priority == true) {
158 DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
159 DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
160 conflict->status = connector_status_disconnected;
161 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
162 } else {
163 DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
164 DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
165 current_status = connector_status_disconnected;
166 }
167 break;
168 }
169 }
170 }
171 return current_status;
172
173}
174
771fe6b9
JG		 175static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
176{
177 struct drm_device *dev = encoder->dev;
178 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
179 struct drm_display_mode *mode = NULL;
180 struct radeon_native_mode *native_mode = &radeon_encoder->native_mode;
181
182 if (native_mode->panel_xres != 0 &&
183 native_mode->panel_yres != 0 &&
184 native_mode->dotclock != 0) {
185 mode = drm_mode_create(dev);
186
187 mode->hdisplay = native_mode->panel_xres;
188 mode->vdisplay = native_mode->panel_yres;
189
190 mode->htotal = mode->hdisplay + native_mode->hblank;
191 mode->hsync_start = mode->hdisplay + native_mode->hoverplus;
192 mode->hsync_end = mode->hsync_start + native_mode->hsync_width;
193 mode->vtotal = mode->vdisplay + native_mode->vblank;
194 mode->vsync_start = mode->vdisplay + native_mode->voverplus;
195 mode->vsync_end = mode->vsync_start + native_mode->vsync_width;
196 mode->clock = native_mode->dotclock;
197 mode->flags = 0;
198
199 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
200 drm_mode_set_name(mode);
201
202 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
203 }
204 return mode;
205}
206
923f6848
AD		 207static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
208{
209 struct drm_device *dev = encoder->dev;
210 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
211 struct drm_display_mode *mode = NULL;
212 struct radeon_native_mode *native_mode = &radeon_encoder->native_mode;
213 int i;
214 struct mode_size {
215 int w;
216 int h;
217 } common_modes[17] = {
218 { 640, 480},
219 { 720, 480},
220 { 800, 600},
221 { 848, 480},
222 {1024, 768},
223 {1152, 768},
224 {1280, 720},
225 {1280, 800},
226 {1280, 854},
227 {1280, 960},
228 {1280, 1024},
229 {1440, 900},
230 {1400, 1050},
231 {1680, 1050},
232 {1600, 1200},
233 {1920, 1080},
234 {1920, 1200}
235 };
236
237 for (i = 0; i < 17; i++) {
238 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
fb1fbf8e
MD		 239 if (common_modes[i].w > native_mode->panel_xres ||
240 common_modes[i].h > native_mode->panel_yres ||
241 (common_modes[i].w == native_mode->panel_xres &&
242 common_modes[i].h == native_mode->panel_yres))
923f6848
AD		 243 continue;
244 }
245 if (common_modes[i].w < 320 || common_modes[i].h < 200)
246 continue;
247
248 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false);
249 drm_mode_probed_add(connector, mode);
250 }
251}
252
771fe6b9
JG		 253int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
254 uint64_t val)
255{
445282db
DA		 256 struct drm_device *dev = connector->dev;
257 struct radeon_device *rdev = dev->dev_private;
258 struct drm_encoder *encoder;
259 struct radeon_encoder *radeon_encoder;
260
261 if (property == rdev->mode_info.coherent_mode_property) {
262 struct radeon_encoder_atom_dig *dig;
263
264 /* need to find digital encoder on connector */
265 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
266 if (!encoder)
267 return 0;
268
269 radeon_encoder = to_radeon_encoder(encoder);
270
271 if (!radeon_encoder->enc_priv)
272 return 0;
273
274 dig = radeon_encoder->enc_priv;
275 dig->coherent_mode = val ? true : false;
276 radeon_property_change_mode(&radeon_encoder->base);
277 }
278
279 if (property == rdev->mode_info.tv_std_property) {
280 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
281 if (!encoder) {
282 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
283 }
284
285 if (!encoder)
286 return 0;
287
288 radeon_encoder = to_radeon_encoder(encoder);
289 if (!radeon_encoder->enc_priv)
290 return 0;
291 if (rdev->is_atom_bios) {
292 struct radeon_encoder_atom_dac *dac_int;
293 dac_int = radeon_encoder->enc_priv;
294 dac_int->tv_std = val;
295 } else {
296 struct radeon_encoder_tv_dac *dac_int;
297 dac_int = radeon_encoder->enc_priv;
298 dac_int->tv_std = val;
299 }
300 radeon_property_change_mode(&radeon_encoder->base);
301 }
302
303 if (property == rdev->mode_info.load_detect_property) {
304 struct radeon_connector *radeon_connector =
305 to_radeon_connector(connector);
306
307 if (val == 0)
308 radeon_connector->dac_load_detect = false;
309 else
310 radeon_connector->dac_load_detect = true;
311 }
312
313 if (property == rdev->mode_info.tmds_pll_property) {
314 struct radeon_encoder_int_tmds *tmds = NULL;
315 bool ret = false;
316 /* need to find digital encoder on connector */
317 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
318 if (!encoder)
319 return 0;
320
321 radeon_encoder = to_radeon_encoder(encoder);
322
323 tmds = radeon_encoder->enc_priv;
324 if (!tmds)
325 return 0;
326
327 if (val == 0) {
328 if (rdev->is_atom_bios)
329 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
330 else
331 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
332 }
333 if (val == 1 || ret == false) {
334 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
335 }
336 radeon_property_change_mode(&radeon_encoder->base);
337 }
338
771fe6b9
JG		 339 return 0;
340}
341
8dfaa8a7
MD		 342static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
343 struct drm_connector *connector)
344{
345 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
346 struct radeon_native_mode *native_mode = &radeon_encoder->native_mode;
347
348 /* Try to get native mode details from EDID if necessary */
349 if (!native_mode->dotclock) {
350 struct drm_display_mode *t, *mode;
351
352 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
353 if (mode->hdisplay == native_mode->panel_xres &&
354 mode->vdisplay == native_mode->panel_yres) {
355 native_mode->hblank = mode->htotal - mode->hdisplay;
356 native_mode->hoverplus = mode->hsync_start - mode->hdisplay;
357 native_mode->hsync_width = mode->hsync_end - mode->hsync_start;
358 native_mode->vblank = mode->vtotal - mode->vdisplay;
359 native_mode->voverplus = mode->vsync_start - mode->vdisplay;
360 native_mode->vsync_width = mode->vsync_end - mode->vsync_start;
361 native_mode->dotclock = mode->clock;
362 DRM_INFO("Determined LVDS native mode details from EDID\n");
363 break;
364 }
365 }
366 }
367 if (!native_mode->dotclock) {
368 DRM_INFO("No LVDS native mode details, disabling RMX\n");
369 radeon_encoder->rmx_type = RMX_OFF;
370 }
371}
771fe6b9
JG		 372
373static int radeon_lvds_get_modes(struct drm_connector *connector)
374{
375 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
376 struct drm_encoder *encoder;
377 int ret = 0;
378 struct drm_display_mode *mode;
379
380 if (radeon_connector->ddc_bus) {
381 ret = radeon_ddc_get_modes(radeon_connector);
382 if (ret > 0) {
7747b713 383 encoder = radeon_best_single_encoder(connector);
8dfaa8a7
MD		 384 if (encoder) {
385 radeon_fixup_lvds_native_mode(encoder, connector);
7747b713
AD		 386 /* add scaled modes */
387 radeon_add_common_modes(encoder, connector);
8dfaa8a7 388 }
771fe6b9
JG		 389 return ret;
390 }
391 }
392
393 encoder = radeon_best_single_encoder(connector);
394 if (!encoder)
395 return 0;
396
397 /* we have no EDID modes */
398 mode = radeon_fp_native_mode(encoder);
399 if (mode) {
400 ret = 1;
401 drm_mode_probed_add(connector, mode);
7747b713
AD		 402 /* add scaled modes */
403 radeon_add_common_modes(encoder, connector);
771fe6b9 404 }
923f6848 405
771fe6b9
JG		 406 return ret;
407}
408
409static int radeon_lvds_mode_valid(struct drm_connector *connector,
410 struct drm_display_mode *mode)
411{
412 return MODE_OK;
413}
414
415static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
416{
417 enum drm_connector_status ret = connector_status_connected;
418 /* check acpi lid status ??? */
419 radeon_connector_update_scratch_regs(connector, ret);
420 return ret;
421}
422
423static void radeon_connector_destroy(struct drm_connector *connector)
424{
425 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
426
427 if (radeon_connector->ddc_bus)
428 radeon_i2c_destroy(radeon_connector->ddc_bus);
429 kfree(radeon_connector->con_priv);
430 drm_sysfs_connector_remove(connector);
431 drm_connector_cleanup(connector);
432 kfree(connector);
433}
434
445282db
DA		 435static int radeon_lvds_set_property(struct drm_connector *connector,
436 struct drm_property *property,
437 uint64_t value)
438{
439 struct drm_device *dev = connector->dev;
440 struct radeon_encoder *radeon_encoder;
441 enum radeon_rmx_type rmx_type;
442
443 DRM_DEBUG("\n");
444 if (property != dev->mode_config.scaling_mode_property)
445 return 0;
446
447 if (connector->encoder)
448 radeon_encoder = to_radeon_encoder(connector->encoder);
449 else {
450 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
451 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
452 }
453
454 switch (value) {
455 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
456 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
457 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
458 default:
459 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
460 }
461 if (radeon_encoder->rmx_type == rmx_type)
462 return 0;
463
464 radeon_encoder->rmx_type = rmx_type;
465
466 radeon_property_change_mode(&radeon_encoder->base);
467 return 0;
468}
469
470
771fe6b9
JG		 471struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
472 .get_modes = radeon_lvds_get_modes,
473 .mode_valid = radeon_lvds_mode_valid,
474 .best_encoder = radeon_best_single_encoder,
475};
476
477struct drm_connector_funcs radeon_lvds_connector_funcs = {
478 .dpms = drm_helper_connector_dpms,
479 .detect = radeon_lvds_detect,
480 .fill_modes = drm_helper_probe_single_connector_modes,
481 .destroy = radeon_connector_destroy,
445282db 482 .set_property = radeon_lvds_set_property,
771fe6b9
JG		 483};
484
485static int radeon_vga_get_modes(struct drm_connector *connector)
486{
487 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
488 int ret;
489
490 ret = radeon_ddc_get_modes(radeon_connector);
491
492 return ret;
493}
494
495static int radeon_vga_mode_valid(struct drm_connector *connector,
496 struct drm_display_mode *mode)
497{
771fe6b9
JG		 498 return MODE_OK;
499}
500
501static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
502{
503 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
504 struct drm_encoder *encoder;
505 struct drm_encoder_helper_funcs *encoder_funcs;
506 bool dret;
507 enum drm_connector_status ret = connector_status_disconnected;
508
4ce001ab
DA		 509 encoder = radeon_best_single_encoder(connector);
510 if (!encoder)
511 ret = connector_status_disconnected;
512
771fe6b9
JG		 513 radeon_i2c_do_lock(radeon_connector, 1);
514 dret = radeon_ddc_probe(radeon_connector);
515 radeon_i2c_do_lock(radeon_connector, 0);
516 if (dret)
517 ret = connector_status_connected;
518 else {
445282db
DA		 519 if (radeon_connector->dac_load_detect) {
520 encoder_funcs = encoder->helper_private;
521 ret = encoder_funcs->detect(encoder, connector);
522 }
771fe6b9
JG		 523 }
524
4ce001ab
DA		 525 if (ret == connector_status_connected)
526 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
771fe6b9
JG		 527 radeon_connector_update_scratch_regs(connector, ret);
528 return ret;
529}
530
531struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
532 .get_modes = radeon_vga_get_modes,
533 .mode_valid = radeon_vga_mode_valid,
534 .best_encoder = radeon_best_single_encoder,
535};
536
537struct drm_connector_funcs radeon_vga_connector_funcs = {
538 .dpms = drm_helper_connector_dpms,
539 .detect = radeon_vga_detect,
540 .fill_modes = drm_helper_probe_single_connector_modes,
541 .destroy = radeon_connector_destroy,
542 .set_property = radeon_connector_set_property,
543};
544
4ce001ab
DA		 545static int radeon_tv_get_modes(struct drm_connector *connector)
546{
547 struct drm_device *dev = connector->dev;
923f6848 548 struct radeon_device *rdev = dev->dev_private;
4ce001ab 549 struct drm_display_mode *tv_mode;
923f6848 550 struct drm_encoder *encoder;
4ce001ab 551
923f6848
AD		 552 encoder = radeon_best_single_encoder(connector);
553 if (!encoder)
554 return 0;
4ce001ab 555
923f6848
AD		 556 /* avivo chips can scale any mode */
557 if (rdev->family >= CHIP_RS600)
558 /* add scaled modes */
559 radeon_add_common_modes(encoder, connector);
560 else {
561 /* only 800x600 is supported right now on pre-avivo chips */
562 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false);
563 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
564 drm_mode_probed_add(connector, tv_mode);
565 }
4ce001ab
DA		 566 return 1;
567}
568
569static int radeon_tv_mode_valid(struct drm_connector *connector,
570 struct drm_display_mode *mode)
571{
572 return MODE_OK;
573}
574
575static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
576{
577 struct drm_encoder *encoder;
578 struct drm_encoder_helper_funcs *encoder_funcs;
445282db
DA		 579 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
580 enum drm_connector_status ret = connector_status_disconnected;
581
582 if (!radeon_connector->dac_load_detect)
583 return ret;
4ce001ab
DA		 584
585 encoder = radeon_best_single_encoder(connector);
586 if (!encoder)
587 ret = connector_status_disconnected;
588 else {
589 encoder_funcs = encoder->helper_private;
590 ret = encoder_funcs->detect(encoder, connector);
591 }
592 if (ret == connector_status_connected)
593 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
594 radeon_connector_update_scratch_regs(connector, ret);
595 return ret;
596}
597
598struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
599 .get_modes = radeon_tv_get_modes,
600 .mode_valid = radeon_tv_mode_valid,
601 .best_encoder = radeon_best_single_encoder,
602};
603
604struct drm_connector_funcs radeon_tv_connector_funcs = {
605 .dpms = drm_helper_connector_dpms,
606 .detect = radeon_tv_detect,
607 .fill_modes = drm_helper_probe_single_connector_modes,
608 .destroy = radeon_connector_destroy,
609 .set_property = radeon_connector_set_property,
610};
611
771fe6b9
JG		 612static int radeon_dvi_get_modes(struct drm_connector *connector)
613{
614 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
615 int ret;
616
617 ret = radeon_ddc_get_modes(radeon_connector);
771fe6b9
JG		 618 return ret;
619}
620
4ce001ab
DA		 621/*
622 * DVI is complicated
623 * Do a DDC probe, if DDC probe passes, get the full EDID so
624 * we can do analog/digital monitor detection at this point.
625 * If the monitor is an analog monitor or we got no DDC,
626 * we need to find the DAC encoder object for this connector.
627 * If we got no DDC, we do load detection on the DAC encoder object.
628 * If we got analog DDC or load detection passes on the DAC encoder
629 * we have to check if this analog encoder is shared with anyone else (TV)
630 * if its shared we have to set the other connector to disconnected.
631 */
771fe6b9
JG		 632static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
633{
634 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
4ce001ab 635 struct drm_encoder *encoder = NULL;
771fe6b9
JG		 636 struct drm_encoder_helper_funcs *encoder_funcs;
637 struct drm_mode_object *obj;
638 int i;
639 enum drm_connector_status ret = connector_status_disconnected;
640 bool dret;
641
642 radeon_i2c_do_lock(radeon_connector, 1);
643 dret = radeon_ddc_probe(radeon_connector);
644 radeon_i2c_do_lock(radeon_connector, 0);
4ce001ab
DA		 645 if (dret) {
646 radeon_i2c_do_lock(radeon_connector, 1);
647 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
648 radeon_i2c_do_lock(radeon_connector, 0);
649
650 if (!radeon_connector->edid) {
651 DRM_ERROR("DDC responded but not EDID found for %s\n",
652 drm_get_connector_name(connector));
653 } else {
654 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
655
656 /* if this isn't a digital monitor
657 then we need to make sure we don't have any
658 TV conflicts */
659 ret = connector_status_connected;
660 }
661 }
662
663 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
664 goto out;
665
666 /* find analog encoder */
445282db
DA		 667 if (radeon_connector->dac_load_detect) {
668 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
669 if (connector->encoder_ids[i] == 0)
670 break;
771fe6b9 671
445282db
DA		 672 obj = drm_mode_object_find(connector->dev,
673 connector->encoder_ids[i],
674 DRM_MODE_OBJECT_ENCODER);
675 if (!obj)
676 continue;
771fe6b9 677
445282db 678 encoder = obj_to_encoder(obj);
771fe6b9 679
445282db
DA		 680 encoder_funcs = encoder->helper_private;
681 if (encoder_funcs->detect) {
682 if (ret != connector_status_connected) {
683 ret = encoder_funcs->detect(encoder, connector);
684 if (ret == connector_status_connected) {
685 radeon_connector->use_digital = false;
686 }
771fe6b9 687 }
445282db 688 break;
771fe6b9
JG		 689 }
690 }
691 }
692
4ce001ab
DA		 693 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
694 encoder) {
695 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
696 }
697
698out:
771fe6b9
JG		 699 /* updated in get modes as well since we need to know if it's analog or digital */
700 radeon_connector_update_scratch_regs(connector, ret);
701 return ret;
702}
703
704/* okay need to be smart in here about which encoder to pick */
705struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
706{
707 int enc_id = connector->encoder_ids[0];
708 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
709 struct drm_mode_object *obj;
710 struct drm_encoder *encoder;
711 int i;
712 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
713 if (connector->encoder_ids[i] == 0)
714 break;
715
716 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
717 if (!obj)
718 continue;
719
720 encoder = obj_to_encoder(obj);
721
4ce001ab 722 if (radeon_connector->use_digital == true) {
771fe6b9
JG		 723 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
724 return encoder;
725 } else {
726 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
727 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
728 return encoder;
729 }
730 }
731
732 /* see if we have a default encoder TODO */
733
734 /* then check use digitial */
735 /* pick the first one */
736 if (enc_id) {
737 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
738 if (!obj)
739 return NULL;
740 encoder = obj_to_encoder(obj);
741 return encoder;
742 }
743 return NULL;
744}
745
746struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
747 .get_modes = radeon_dvi_get_modes,
748 .mode_valid = radeon_vga_mode_valid,
749 .best_encoder = radeon_dvi_encoder,
750};
751
752struct drm_connector_funcs radeon_dvi_connector_funcs = {
753 .dpms = drm_helper_connector_dpms,
754 .detect = radeon_dvi_detect,
755 .fill_modes = drm_helper_probe_single_connector_modes,
756 .set_property = radeon_connector_set_property,
757 .destroy = radeon_connector_destroy,
758};
759
760void
761radeon_add_atom_connector(struct drm_device *dev,
762 uint32_t connector_id,
763 uint32_t supported_device,
764 int connector_type,
765 struct radeon_i2c_bus_rec *i2c_bus,
766 bool linkb,
767 uint32_t igp_lane_info)
768{
445282db 769 struct radeon_device *rdev = dev->dev_private;
771fe6b9
JG		 770 struct drm_connector *connector;
771 struct radeon_connector *radeon_connector;
772 struct radeon_connector_atom_dig *radeon_dig_connector;
773 uint32_t subpixel_order = SubPixelNone;
774
775 /* fixme - tv/cv/din */
4ce001ab 776 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
771fe6b9
JG		 777 return;
778
779 /* see if we already added it */
780 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
781 radeon_connector = to_radeon_connector(connector);
782 if (radeon_connector->connector_id == connector_id) {
783 radeon_connector->devices |= supported_device;
784 return;
785 }
786 }
787
788 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
789 if (!radeon_connector)
790 return;
791
792 connector = &radeon_connector->base;
793
794 radeon_connector->connector_id = connector_id;
795 radeon_connector->devices = supported_device;
796 switch (connector_type) {
797 case DRM_MODE_CONNECTOR_VGA:
798 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
799 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
800 if (i2c_bus->valid) {
801 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
802 if (!radeon_connector->ddc_bus)
803 goto failed;
804 }
445282db
DA		 805 drm_connector_attach_property(&radeon_connector->base,
806 rdev->mode_info.load_detect_property,
807 1);
771fe6b9
JG		 808 break;
809 case DRM_MODE_CONNECTOR_DVIA:
810 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
811 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
812 if (i2c_bus->valid) {
813 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
814 if (!radeon_connector->ddc_bus)
815 goto failed;
816 }
445282db
DA		 817 drm_connector_attach_property(&radeon_connector->base,
818 rdev->mode_info.load_detect_property,
819 1);
771fe6b9
JG		 820 break;
821 case DRM_MODE_CONNECTOR_DVII:
822 case DRM_MODE_CONNECTOR_DVID:
823 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
824 if (!radeon_dig_connector)
825 goto failed;
826 radeon_dig_connector->linkb = linkb;
827 radeon_dig_connector->igp_lane_info = igp_lane_info;
828 radeon_connector->con_priv = radeon_dig_connector;
829 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
830 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
831 if (i2c_bus->valid) {
832 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
833 if (!radeon_connector->ddc_bus)
834 goto failed;
835 }
836 subpixel_order = SubPixelHorizontalRGB;
445282db
DA		 837 drm_connector_attach_property(&radeon_connector->base,
838 rdev->mode_info.coherent_mode_property,
839 1);
840 drm_connector_attach_property(&radeon_connector->base,
841 rdev->mode_info.load_detect_property,
842 1);
771fe6b9
JG		 843 break;
844 case DRM_MODE_CONNECTOR_HDMIA:
845 case DRM_MODE_CONNECTOR_HDMIB:
846 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
847 if (!radeon_dig_connector)
848 goto failed;
849 radeon_dig_connector->linkb = linkb;
850 radeon_dig_connector->igp_lane_info = igp_lane_info;
851 radeon_connector->con_priv = radeon_dig_connector;
852 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
853 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
854 if (i2c_bus->valid) {
855 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
856 if (!radeon_connector->ddc_bus)
857 goto failed;
858 }
445282db
DA		 859 drm_connector_attach_property(&radeon_connector->base,
860 rdev->mode_info.coherent_mode_property,
861 1);
771fe6b9
JG		 862 subpixel_order = SubPixelHorizontalRGB;
863 break;
864 case DRM_MODE_CONNECTOR_DisplayPort:
865 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
866 if (!radeon_dig_connector)
867 goto failed;
868 radeon_dig_connector->linkb = linkb;
869 radeon_dig_connector->igp_lane_info = igp_lane_info;
870 radeon_connector->con_priv = radeon_dig_connector;
871 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
872 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
873 if (i2c_bus->valid) {
874 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
875 if (!radeon_connector->ddc_bus)
876 goto failed;
877 }
878 subpixel_order = SubPixelHorizontalRGB;
879 break;
880 case DRM_MODE_CONNECTOR_SVIDEO:
881 case DRM_MODE_CONNECTOR_Composite:
882 case DRM_MODE_CONNECTOR_9PinDIN:
4ce001ab
DA		 883 if (radeon_tv == 1) {
884 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
885 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
886 }
445282db
DA		 887 drm_connector_attach_property(&radeon_connector->base,
888 rdev->mode_info.load_detect_property,
889 1);
771fe6b9
JG		 890 break;
891 case DRM_MODE_CONNECTOR_LVDS:
892 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
893 if (!radeon_dig_connector)
894 goto failed;
895 radeon_dig_connector->linkb = linkb;
896 radeon_dig_connector->igp_lane_info = igp_lane_info;
897 radeon_connector->con_priv = radeon_dig_connector;
898 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
899 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
900 if (i2c_bus->valid) {
901 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
902 if (!radeon_connector->ddc_bus)
903 goto failed;
904 }
445282db
DA		 905 drm_mode_create_scaling_mode_property(dev);
906 drm_connector_attach_property(&radeon_connector->base,
907 dev->mode_config.scaling_mode_property,
908 DRM_MODE_SCALE_FULLSCREEN);
771fe6b9
JG		 909 subpixel_order = SubPixelHorizontalRGB;
910 break;
911 }
912
913 connector->display_info.subpixel_order = subpixel_order;
914 drm_sysfs_connector_add(connector);
915 return;
916
917failed:
918 if (radeon_connector->ddc_bus)
919 radeon_i2c_destroy(radeon_connector->ddc_bus);
920 drm_connector_cleanup(connector);
921 kfree(connector);
922}
923
924void
925radeon_add_legacy_connector(struct drm_device *dev,
926 uint32_t connector_id,
927 uint32_t supported_device,
928 int connector_type,
929 struct radeon_i2c_bus_rec *i2c_bus)
930{
445282db 931 struct radeon_device *rdev = dev->dev_private;
771fe6b9
JG		 932 struct drm_connector *connector;
933 struct radeon_connector *radeon_connector;
934 uint32_t subpixel_order = SubPixelNone;
935
936 /* fixme - tv/cv/din */
4ce001ab 937 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
771fe6b9
JG		 938 return;
939
940 /* see if we already added it */
941 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
942 radeon_connector = to_radeon_connector(connector);
943 if (radeon_connector->connector_id == connector_id) {
944 radeon_connector->devices |= supported_device;
945 return;
946 }
947 }
948
949 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
950 if (!radeon_connector)
951 return;
952
953 connector = &radeon_connector->base;
954
955 radeon_connector->connector_id = connector_id;
956 radeon_connector->devices = supported_device;
957 switch (connector_type) {
958 case DRM_MODE_CONNECTOR_VGA:
959 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
960 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
961 if (i2c_bus->valid) {
962 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
963 if (!radeon_connector->ddc_bus)
964 goto failed;
965 }
445282db
DA		 966 drm_connector_attach_property(&radeon_connector->base,
967 rdev->mode_info.load_detect_property,
968 1);
771fe6b9
JG		 969 break;
970 case DRM_MODE_CONNECTOR_DVIA:
971 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
972 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
973 if (i2c_bus->valid) {
974 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
975 if (!radeon_connector->ddc_bus)
976 goto failed;
977 }
445282db
DA		 978 drm_connector_attach_property(&radeon_connector->base,
979 rdev->mode_info.load_detect_property,
980 1);
771fe6b9
JG		 981 break;
982 case DRM_MODE_CONNECTOR_DVII:
983 case DRM_MODE_CONNECTOR_DVID:
984 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
985 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
986 if (i2c_bus->valid) {
987 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
988 if (!radeon_connector->ddc_bus)
989 goto failed;
445282db
DA		 990 drm_connector_attach_property(&radeon_connector->base,
991 rdev->mode_info.load_detect_property,
992 1);
771fe6b9
JG		 993 }
994 subpixel_order = SubPixelHorizontalRGB;
995 break;
996 case DRM_MODE_CONNECTOR_SVIDEO:
997 case DRM_MODE_CONNECTOR_Composite:
998 case DRM_MODE_CONNECTOR_9PinDIN:
4ce001ab
DA		 999 if (radeon_tv == 1) {
1000 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1001 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
445282db
DA		 1002 drm_connector_attach_property(&radeon_connector->base,
1003 rdev->mode_info.load_detect_property,
1004 1);
4ce001ab 1005 }
771fe6b9
JG		 1006 break;
1007 case DRM_MODE_CONNECTOR_LVDS:
1008 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1009 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1010 if (i2c_bus->valid) {
1011 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1012 if (!radeon_connector->ddc_bus)
1013 goto failed;
1014 }
445282db
DA		 1015 drm_connector_attach_property(&radeon_connector->base,
1016 dev->mode_config.scaling_mode_property,
1017 DRM_MODE_SCALE_FULLSCREEN);
771fe6b9
JG		 1018 subpixel_order = SubPixelHorizontalRGB;
1019 break;
1020 }
1021
1022 connector->display_info.subpixel_order = subpixel_order;
1023 drm_sysfs_connector_add(connector);
1024 return;
1025
1026failed:
1027 if (radeon_connector->ddc_bus)
1028 radeon_i2c_destroy(radeon_connector->ddc_bus);
1029 drm_connector_cleanup(connector);
1030 kfree(connector);
1031}
Linux 6.x block layer and io_uring tree(s)