2 * Copyright 2007-8 Advanced Micro Devices, Inc.
3 * Copyright 2008 Red Hat Inc.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
23 * Authors: Dave Airlie
28 #include "drm_crtc_helper.h"
29 #include "radeon_drm.h"
34 radeon_combios_connected_scratch_regs(struct drm_connector *connector,
35 struct drm_encoder *encoder,
38 radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
39 struct drm_encoder *encoder,
42 static void radeon_property_change_mode(struct drm_encoder *encoder)
44 struct drm_crtc *crtc = encoder->crtc;
46 if (crtc && crtc->enabled) {
47 drm_crtc_helper_set_mode(crtc, &crtc->mode,
48 crtc->x, crtc->y, crtc->fb);
52 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
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;
63 best_encoder = connector_funcs->best_encoder(connector);
65 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
66 if (connector->encoder_ids[i] == 0)
69 obj = drm_mode_object_find(connector->dev,
70 connector->encoder_ids[i],
71 DRM_MODE_OBJECT_ENCODER);
75 encoder = obj_to_encoder(obj);
77 if ((encoder == best_encoder) && (status == connector_status_connected))
82 if (rdev->is_atom_bios)
83 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
85 radeon_combios_connected_scratch_regs(connector, encoder, connected);
90 struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
92 struct drm_mode_object *obj;
93 struct drm_encoder *encoder;
96 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
97 if (connector->encoder_ids[i] == 0)
100 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
104 encoder = obj_to_encoder(obj);
105 if (encoder->encoder_type == encoder_type)
111 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
113 int enc_id = connector->encoder_ids[0];
114 struct drm_mode_object *obj;
115 struct drm_encoder *encoder;
117 /* pick the encoder ids */
119 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
122 encoder = obj_to_encoder(obj);
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
134 static enum drm_connector_status
135 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
136 struct drm_encoder *encoder,
137 enum drm_connector_status current_status,
140 struct drm_device *dev = connector->dev;
141 struct drm_connector *conflict;
144 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
145 if (conflict == connector)
148 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
149 if (conflict->encoder_ids[i] == 0)
152 /* if the IDs match */
153 if (conflict->encoder_ids[i] == encoder->base.id) {
154 if (conflict->status != connector_status_connected)
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);
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;
171 return current_status;
175 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
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;
182 if (native_mode->panel_xres != 0 &&
183 native_mode->panel_yres != 0 &&
184 native_mode->dotclock != 0) {
185 mode = drm_mode_create(dev);
187 mode->hdisplay = native_mode->panel_xres;
188 mode->vdisplay = native_mode->panel_yres;
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;
199 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
200 drm_mode_set_name(mode);
202 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
207 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
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;
217 } common_modes[17] = {
237 for (i = 0; i < 17; i++) {
238 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
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))
245 if (common_modes[i].w < 320 || common_modes[i].h < 200)
248 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false);
249 drm_mode_probed_add(connector, mode);
253 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
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;
261 if (property == rdev->mode_info.coherent_mode_property) {
262 struct radeon_encoder_atom_dig *dig;
264 /* need to find digital encoder on connector */
265 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
269 radeon_encoder = to_radeon_encoder(encoder);
271 if (!radeon_encoder->enc_priv)
274 dig = radeon_encoder->enc_priv;
275 dig->coherent_mode = val ? true : false;
276 radeon_property_change_mode(&radeon_encoder->base);
279 if (property == rdev->mode_info.tv_std_property) {
280 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
282 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
288 radeon_encoder = to_radeon_encoder(encoder);
289 if (!radeon_encoder->enc_priv)
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;
296 struct radeon_encoder_tv_dac *dac_int;
297 dac_int = radeon_encoder->enc_priv;
298 dac_int->tv_std = val;
300 radeon_property_change_mode(&radeon_encoder->base);
303 if (property == rdev->mode_info.load_detect_property) {
304 struct radeon_connector *radeon_connector =
305 to_radeon_connector(connector);
308 radeon_connector->dac_load_detect = false;
310 radeon_connector->dac_load_detect = true;
313 if (property == rdev->mode_info.tmds_pll_property) {
314 struct radeon_encoder_int_tmds *tmds = NULL;
316 /* need to find digital encoder on connector */
317 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
321 radeon_encoder = to_radeon_encoder(encoder);
323 tmds = radeon_encoder->enc_priv;
328 if (rdev->is_atom_bios)
329 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
331 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
333 if (val == 1 || ret == false) {
334 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
336 radeon_property_change_mode(&radeon_encoder->base);
342 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
343 struct drm_connector *connector)
345 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
346 struct radeon_native_mode *native_mode = &radeon_encoder->native_mode;
348 /* Try to get native mode details from EDID if necessary */
349 if (!native_mode->dotclock) {
350 struct drm_display_mode *t, *mode;
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");
367 if (!native_mode->dotclock) {
368 DRM_INFO("No LVDS native mode details, disabling RMX\n");
369 radeon_encoder->rmx_type = RMX_OFF;
373 static int radeon_lvds_get_modes(struct drm_connector *connector)
375 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
376 struct drm_encoder *encoder;
378 struct drm_display_mode *mode;
380 if (radeon_connector->ddc_bus) {
381 ret = radeon_ddc_get_modes(radeon_connector);
383 encoder = radeon_best_single_encoder(connector);
385 radeon_fixup_lvds_native_mode(encoder, connector);
386 /* add scaled modes */
387 radeon_add_common_modes(encoder, connector);
393 encoder = radeon_best_single_encoder(connector);
397 /* we have no EDID modes */
398 mode = radeon_fp_native_mode(encoder);
401 drm_mode_probed_add(connector, mode);
402 /* add scaled modes */
403 radeon_add_common_modes(encoder, connector);
409 static int radeon_lvds_mode_valid(struct drm_connector *connector,
410 struct drm_display_mode *mode)
415 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
417 enum drm_connector_status ret = connector_status_connected;
418 /* check acpi lid status ??? */
419 radeon_connector_update_scratch_regs(connector, ret);
423 static void radeon_connector_destroy(struct drm_connector *connector)
425 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
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);
435 static int radeon_lvds_set_property(struct drm_connector *connector,
436 struct drm_property *property,
439 struct drm_device *dev = connector->dev;
440 struct radeon_encoder *radeon_encoder;
441 enum radeon_rmx_type rmx_type;
444 if (property != dev->mode_config.scaling_mode_property)
447 if (connector->encoder)
448 radeon_encoder = to_radeon_encoder(connector->encoder);
450 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
451 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
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;
459 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
461 if (radeon_encoder->rmx_type == rmx_type)
464 radeon_encoder->rmx_type = rmx_type;
466 radeon_property_change_mode(&radeon_encoder->base);
471 struct 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,
477 struct 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,
482 .set_property = radeon_lvds_set_property,
485 static int radeon_vga_get_modes(struct drm_connector *connector)
487 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
490 ret = radeon_ddc_get_modes(radeon_connector);
495 static int radeon_vga_mode_valid(struct drm_connector *connector,
496 struct drm_display_mode *mode)
501 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
503 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
504 struct drm_encoder *encoder;
505 struct drm_encoder_helper_funcs *encoder_funcs;
507 enum drm_connector_status ret = connector_status_disconnected;
509 encoder = radeon_best_single_encoder(connector);
511 ret = connector_status_disconnected;
513 radeon_i2c_do_lock(radeon_connector, 1);
514 dret = radeon_ddc_probe(radeon_connector);
515 radeon_i2c_do_lock(radeon_connector, 0);
517 ret = connector_status_connected;
519 if (radeon_connector->dac_load_detect) {
520 encoder_funcs = encoder->helper_private;
521 ret = encoder_funcs->detect(encoder, connector);
525 if (ret == connector_status_connected)
526 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
527 radeon_connector_update_scratch_regs(connector, ret);
531 struct 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,
537 struct 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,
545 static int radeon_tv_get_modes(struct drm_connector *connector)
547 struct drm_device *dev = connector->dev;
548 struct radeon_device *rdev = dev->dev_private;
549 struct drm_display_mode *tv_mode;
550 struct drm_encoder *encoder;
552 encoder = radeon_best_single_encoder(connector);
556 /* avivo chips can scale any mode */
557 if (rdev->family >= CHIP_RS600)
558 /* add scaled modes */
559 radeon_add_common_modes(encoder, connector);
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);
569 static int radeon_tv_mode_valid(struct drm_connector *connector,
570 struct drm_display_mode *mode)
575 static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
577 struct drm_encoder *encoder;
578 struct drm_encoder_helper_funcs *encoder_funcs;
579 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
580 enum drm_connector_status ret = connector_status_disconnected;
582 if (!radeon_connector->dac_load_detect)
585 encoder = radeon_best_single_encoder(connector);
587 ret = connector_status_disconnected;
589 encoder_funcs = encoder->helper_private;
590 ret = encoder_funcs->detect(encoder, connector);
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);
598 struct 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,
604 struct 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,
612 static int radeon_dvi_get_modes(struct drm_connector *connector)
614 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
617 ret = radeon_ddc_get_modes(radeon_connector);
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.
632 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
634 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
635 struct drm_encoder *encoder = NULL;
636 struct drm_encoder_helper_funcs *encoder_funcs;
637 struct drm_mode_object *obj;
639 enum drm_connector_status ret = connector_status_disconnected;
642 radeon_i2c_do_lock(radeon_connector, 1);
643 dret = radeon_ddc_probe(radeon_connector);
644 radeon_i2c_do_lock(radeon_connector, 0);
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);
650 if (!radeon_connector->edid) {
651 DRM_ERROR("DDC responded but not EDID found for %s\n",
652 drm_get_connector_name(connector));
654 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
656 /* if this isn't a digital monitor
657 then we need to make sure we don't have any
659 ret = connector_status_connected;
663 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
666 /* find analog encoder */
667 if (radeon_connector->dac_load_detect) {
668 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
669 if (connector->encoder_ids[i] == 0)
672 obj = drm_mode_object_find(connector->dev,
673 connector->encoder_ids[i],
674 DRM_MODE_OBJECT_ENCODER);
678 encoder = obj_to_encoder(obj);
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;
693 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
695 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
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);
704 /* okay need to be smart in here about which encoder to pick */
705 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
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;
712 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
713 if (connector->encoder_ids[i] == 0)
716 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
720 encoder = obj_to_encoder(obj);
722 if (radeon_connector->use_digital == true) {
723 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
726 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
727 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
732 /* see if we have a default encoder TODO */
734 /* then check use digitial */
735 /* pick the first one */
737 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
740 encoder = obj_to_encoder(obj);
746 struct 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,
752 struct 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,
761 radeon_add_atom_connector(struct drm_device *dev,
762 uint32_t connector_id,
763 uint32_t supported_device,
765 struct radeon_i2c_bus_rec *i2c_bus,
767 uint32_t igp_lane_info)
769 struct radeon_device *rdev = dev->dev_private;
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;
775 /* fixme - tv/cv/din */
776 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
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;
788 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
789 if (!radeon_connector)
792 connector = &radeon_connector->base;
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)
805 radeon_connector->dac_load_detect = true;
806 drm_connector_attach_property(&radeon_connector->base,
807 rdev->mode_info.load_detect_property,
810 case DRM_MODE_CONNECTOR_DVIA:
811 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
812 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
813 if (i2c_bus->valid) {
814 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
815 if (!radeon_connector->ddc_bus)
818 radeon_connector->dac_load_detect = true;
819 drm_connector_attach_property(&radeon_connector->base,
820 rdev->mode_info.load_detect_property,
823 case DRM_MODE_CONNECTOR_DVII:
824 case DRM_MODE_CONNECTOR_DVID:
825 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
826 if (!radeon_dig_connector)
828 radeon_dig_connector->linkb = linkb;
829 radeon_dig_connector->igp_lane_info = igp_lane_info;
830 radeon_connector->con_priv = radeon_dig_connector;
831 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
832 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
833 if (i2c_bus->valid) {
834 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
835 if (!radeon_connector->ddc_bus)
838 subpixel_order = SubPixelHorizontalRGB;
839 drm_connector_attach_property(&radeon_connector->base,
840 rdev->mode_info.coherent_mode_property,
842 radeon_connector->dac_load_detect = true;
843 drm_connector_attach_property(&radeon_connector->base,
844 rdev->mode_info.load_detect_property,
847 case DRM_MODE_CONNECTOR_HDMIA:
848 case DRM_MODE_CONNECTOR_HDMIB:
849 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
850 if (!radeon_dig_connector)
852 radeon_dig_connector->linkb = linkb;
853 radeon_dig_connector->igp_lane_info = igp_lane_info;
854 radeon_connector->con_priv = radeon_dig_connector;
855 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
856 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
857 if (i2c_bus->valid) {
858 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
859 if (!radeon_connector->ddc_bus)
862 drm_connector_attach_property(&radeon_connector->base,
863 rdev->mode_info.coherent_mode_property,
865 subpixel_order = SubPixelHorizontalRGB;
867 case DRM_MODE_CONNECTOR_DisplayPort:
868 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
869 if (!radeon_dig_connector)
871 radeon_dig_connector->linkb = linkb;
872 radeon_dig_connector->igp_lane_info = igp_lane_info;
873 radeon_connector->con_priv = radeon_dig_connector;
874 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
875 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
876 if (i2c_bus->valid) {
877 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
878 if (!radeon_connector->ddc_bus)
881 subpixel_order = SubPixelHorizontalRGB;
883 case DRM_MODE_CONNECTOR_SVIDEO:
884 case DRM_MODE_CONNECTOR_Composite:
885 case DRM_MODE_CONNECTOR_9PinDIN:
886 if (radeon_tv == 1) {
887 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
888 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
890 radeon_connector->dac_load_detect = true;
891 drm_connector_attach_property(&radeon_connector->base,
892 rdev->mode_info.load_detect_property,
895 case DRM_MODE_CONNECTOR_LVDS:
896 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
897 if (!radeon_dig_connector)
899 radeon_dig_connector->linkb = linkb;
900 radeon_dig_connector->igp_lane_info = igp_lane_info;
901 radeon_connector->con_priv = radeon_dig_connector;
902 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
903 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
904 if (i2c_bus->valid) {
905 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
906 if (!radeon_connector->ddc_bus)
909 drm_mode_create_scaling_mode_property(dev);
910 drm_connector_attach_property(&radeon_connector->base,
911 dev->mode_config.scaling_mode_property,
912 DRM_MODE_SCALE_FULLSCREEN);
913 subpixel_order = SubPixelHorizontalRGB;
917 connector->display_info.subpixel_order = subpixel_order;
918 drm_sysfs_connector_add(connector);
922 if (radeon_connector->ddc_bus)
923 radeon_i2c_destroy(radeon_connector->ddc_bus);
924 drm_connector_cleanup(connector);
929 radeon_add_legacy_connector(struct drm_device *dev,
930 uint32_t connector_id,
931 uint32_t supported_device,
933 struct radeon_i2c_bus_rec *i2c_bus)
935 struct radeon_device *rdev = dev->dev_private;
936 struct drm_connector *connector;
937 struct radeon_connector *radeon_connector;
938 uint32_t subpixel_order = SubPixelNone;
940 /* fixme - tv/cv/din */
941 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
944 /* see if we already added it */
945 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
946 radeon_connector = to_radeon_connector(connector);
947 if (radeon_connector->connector_id == connector_id) {
948 radeon_connector->devices |= supported_device;
953 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
954 if (!radeon_connector)
957 connector = &radeon_connector->base;
959 radeon_connector->connector_id = connector_id;
960 radeon_connector->devices = supported_device;
961 switch (connector_type) {
962 case DRM_MODE_CONNECTOR_VGA:
963 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
964 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
965 if (i2c_bus->valid) {
966 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
967 if (!radeon_connector->ddc_bus)
970 radeon_connector->dac_load_detect = true;
971 drm_connector_attach_property(&radeon_connector->base,
972 rdev->mode_info.load_detect_property,
975 case DRM_MODE_CONNECTOR_DVIA:
976 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
977 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
978 if (i2c_bus->valid) {
979 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
980 if (!radeon_connector->ddc_bus)
983 radeon_connector->dac_load_detect = true;
984 drm_connector_attach_property(&radeon_connector->base,
985 rdev->mode_info.load_detect_property,
988 case DRM_MODE_CONNECTOR_DVII:
989 case DRM_MODE_CONNECTOR_DVID:
990 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
991 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
992 if (i2c_bus->valid) {
993 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
994 if (!radeon_connector->ddc_bus)
996 radeon_connector->dac_load_detect = true;
997 drm_connector_attach_property(&radeon_connector->base,
998 rdev->mode_info.load_detect_property,
1001 subpixel_order = SubPixelHorizontalRGB;
1003 case DRM_MODE_CONNECTOR_SVIDEO:
1004 case DRM_MODE_CONNECTOR_Composite:
1005 case DRM_MODE_CONNECTOR_9PinDIN:
1006 if (radeon_tv == 1) {
1007 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1008 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1009 radeon_connector->dac_load_detect = true;
1010 drm_connector_attach_property(&radeon_connector->base,
1011 rdev->mode_info.load_detect_property,
1015 case DRM_MODE_CONNECTOR_LVDS:
1016 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1017 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1018 if (i2c_bus->valid) {
1019 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1020 if (!radeon_connector->ddc_bus)
1023 drm_connector_attach_property(&radeon_connector->base,
1024 dev->mode_config.scaling_mode_property,
1025 DRM_MODE_SCALE_FULLSCREEN);
1026 subpixel_order = SubPixelHorizontalRGB;
1030 connector->display_info.subpixel_order = subpixel_order;
1031 drm_sysfs_connector_add(connector);
1035 if (radeon_connector->ddc_bus)
1036 radeon_i2c_destroy(radeon_connector->ddc_bus);
1037 drm_connector_cleanup(connector);