drm/radeon/kms: add initial radeon tv-out support.

This ports the tv-out code from the DDX to KMS.

adds a radeon.tv module option, radeon.tv=0 to disable tv

Signed-off-by: Dave Airlie <airlied@redhat.com>

1 files changed, 178 insertions, 37 deletions

diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 70ede6a52d4e..6a2b0296adff 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -94,6 +94,54 @@ struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
         return NULL;
 }
 
+
+/*
+ * radeon_connector_analog_encoder_conflict_solve
+ * - search for other connectors sharing this encoder
+ *   if priority is true, then set them disconnected if this is connected
+ *   if priority is false, set us disconnected if they are connected
+ */
+static enum drm_connector_status
+radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
+                                               struct drm_encoder *encoder,
+                                               enum drm_connector_status current_status,
+                                               bool priority)
+{
+        struct drm_device *dev = connector->dev;
+        struct drm_connector *conflict;
+        int i;
+
+        list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
+                if (conflict == connector)
+                        continue;
+
+                for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
+                        if (conflict->encoder_ids[i] == 0)
+                                break;
+
+                        /* if the IDs match */
+                        if (conflict->encoder_ids[i] == encoder->base.id) {
+                                if (conflict->status != connector_status_connected)
+                                        continue;
+
+                                if (priority == true) {
+                                        DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
+                                        DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
+                                        conflict->status = connector_status_disconnected;
+                                        radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
+                                } else {
+                                        DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
+                                        DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
+                                        current_status = connector_status_disconnected;
+                                }
+                                break;
+                        }
+                }
+        }
+        return current_status;
+
+}
+
 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
 {
         struct drm_device *dev = encoder->dev;
@@ -213,7 +261,6 @@ static int radeon_vga_get_modes(struct drm_connector *connector)
 static int radeon_vga_mode_valid(struct drm_connector *connector,
                                   struct drm_display_mode *mode)
 {
-
         return MODE_OK;
 }
 
@@ -225,22 +272,22 @@ static enum drm_connector_status radeon_vga_detect(struct drm_connector *connect
         bool dret;
         enum drm_connector_status ret = connector_status_disconnected;
 
+        encoder = radeon_best_single_encoder(connector);
+        if (!encoder)
+                ret = connector_status_disconnected;
+
         radeon_i2c_do_lock(radeon_connector, 1);
         dret = radeon_ddc_probe(radeon_connector);
         radeon_i2c_do_lock(radeon_connector, 0);
         if (dret)
                 ret = connector_status_connected;
         else {
-                /* if EDID fails to a load detect */
-                encoder = radeon_best_single_encoder(connector);
-                if (!encoder)
-                        ret = connector_status_disconnected;
-                else {
-                        encoder_funcs = encoder->helper_private;
-                        ret = encoder_funcs->detect(encoder, connector);
-                }
+                encoder_funcs = encoder->helper_private;
+                ret = encoder_funcs->detect(encoder, connector);
         }
 
+        if (ret == connector_status_connected)
+                ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
         radeon_connector_update_scratch_regs(connector, ret);
         return ret;
 }
@@ -259,21 +306,87 @@ struct drm_connector_funcs radeon_vga_connector_funcs = {
         .set_property = radeon_connector_set_property,
 };
 
+static struct drm_display_mode tv_fixed_mode = {
+        DRM_MODE("800x600", DRM_MODE_TYPE_DEFAULT, 38250, 800, 832,
+                 912, 1024, 0, 600, 603, 607, 624, 0, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC),
+};
+
+static int radeon_tv_get_modes(struct drm_connector *connector)
+{
+        struct drm_device *dev = connector->dev;
+        struct drm_display_mode *tv_mode;
+
+        tv_mode = drm_mode_duplicate(dev, &tv_fixed_mode);
+        tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
+
+        drm_mode_probed_add(connector, tv_mode);
+
+        return 1;
+}
+
+static int radeon_tv_mode_valid(struct drm_connector *connector,
+                                struct drm_display_mode *mode)
+{
+        return MODE_OK;
+}
+
+static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
+{
+        struct drm_encoder *encoder;
+        struct drm_encoder_helper_funcs *encoder_funcs;
+        int ret;
+
+        encoder = radeon_best_single_encoder(connector);
+        if (!encoder)
+                ret = connector_status_disconnected;
+        else {
+                encoder_funcs = encoder->helper_private;
+                ret = encoder_funcs->detect(encoder, connector);
+        }
+        if (ret == connector_status_connected)
+                ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
+        radeon_connector_update_scratch_regs(connector, ret);
+        return ret;
+}
+
+struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
+        .get_modes = radeon_tv_get_modes,
+        .mode_valid = radeon_tv_mode_valid,
+        .best_encoder = radeon_best_single_encoder,
+};
+
+struct drm_connector_funcs radeon_tv_connector_funcs = {
+        .dpms = drm_helper_connector_dpms,
+        .detect = radeon_tv_detect,
+        .fill_modes = drm_helper_probe_single_connector_modes,
+        .destroy = radeon_connector_destroy,
+        .set_property = radeon_connector_set_property,
+};
+
 static int radeon_dvi_get_modes(struct drm_connector *connector)
 {
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         int ret;
 
         ret = radeon_ddc_get_modes(radeon_connector);
-        /* reset scratch regs here since radeon_dvi_detect doesn't check digital bit */
-        radeon_connector_update_scratch_regs(connector, connector_status_connected);
         return ret;
 }
 
+/*
+ * DVI is complicated
+ * Do a DDC probe, if DDC probe passes, get the full EDID so
+ * we can do analog/digital monitor detection at this point.
+ * If the monitor is an analog monitor or we got no DDC,
+ * we need to find the DAC encoder object for this connector.
+ * If we got no DDC, we do load detection on the DAC encoder object.
+ * If we got analog DDC or load detection passes on the DAC encoder
+ * we have to check if this analog encoder is shared with anyone else (TV)
+ * if its shared we have to set the other connector to disconnected.
+ */
 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
 {
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
-        struct drm_encoder *encoder;
+        struct drm_encoder *encoder = NULL;
         struct drm_encoder_helper_funcs *encoder_funcs;
         struct drm_mode_object *obj;
         int i;
@@ -283,32 +396,58 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
         radeon_i2c_do_lock(radeon_connector, 1);
         dret = radeon_ddc_probe(radeon_connector);
         radeon_i2c_do_lock(radeon_connector, 0);
-        if (dret)
-                ret = connector_status_connected;
-        else {
-                for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
-                        if (connector->encoder_ids[i] == 0)
-                                break;
+        if (dret) {
+                radeon_i2c_do_lock(radeon_connector, 1);
+                radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
+                radeon_i2c_do_lock(radeon_connector, 0);
+
+                if (!radeon_connector->edid) {
+                        DRM_ERROR("DDC responded but not EDID found for %s\n",
+                                  drm_get_connector_name(connector));
+                } else {
+                        radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
+
+                        /* if this isn't a digital monitor
+                           then we need to make sure we don't have any
+                           TV conflicts */
+                        ret = connector_status_connected;
+                }
+        }
+
+        if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
+                goto out;
+
+        /* find analog encoder */
+        for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
+                if (connector->encoder_ids[i] == 0)
+                        break;
 
-                        obj = drm_mode_object_find(connector->dev,
-                                                   connector->encoder_ids[i],
-                                                   DRM_MODE_OBJECT_ENCODER);
-                        if (!obj)
-                                continue;
+                obj = drm_mode_object_find(connector->dev,
+                                           connector->encoder_ids[i],
+                                           DRM_MODE_OBJECT_ENCODER);
+                if (!obj)
+                        continue;
 
-                        encoder = obj_to_encoder(obj);
+                encoder = obj_to_encoder(obj);
 
-                        encoder_funcs = encoder->helper_private;
-                        if (encoder_funcs->detect) {
+                encoder_funcs = encoder->helper_private;
+                if (encoder_funcs->detect) {
+                        if (ret != connector_status_connected) {
                                 ret = encoder_funcs->detect(encoder, connector);
                                 if (ret == connector_status_connected) {
-                                        radeon_connector->use_digital = 0;
-                                        break;
+                                        radeon_connector->use_digital = false;
                                 }
                         }
+                        break;
                 }
         }
 
+        if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
+            encoder) {
+                ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
+        }
+
+out:
         /* updated in get modes as well since we need to know if it's analog or digital */
         radeon_connector_update_scratch_regs(connector, ret);
         return ret;
@@ -332,7 +471,7 @@ struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
 
                 encoder = obj_to_encoder(obj);
 
-                if (radeon_connector->use_digital) {
+                if (radeon_connector->use_digital == true) {
                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
                                 return encoder;
                 } else {
@@ -385,10 +524,7 @@ radeon_add_atom_connector(struct drm_device *dev,
         uint32_t subpixel_order = SubPixelNone;
 
         /* fixme - tv/cv/din */
-        if ((connector_type == DRM_MODE_CONNECTOR_Unknown) ||
-            (connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
-            (connector_type == DRM_MODE_CONNECTOR_Composite) ||
-            (connector_type == DRM_MODE_CONNECTOR_9PinDIN))
+        if (connector_type == DRM_MODE_CONNECTOR_Unknown)
                 return;
 
         /* see if we already added it */
@@ -480,6 +616,10 @@ radeon_add_atom_connector(struct drm_device *dev,
         case DRM_MODE_CONNECTOR_SVIDEO:
         case DRM_MODE_CONNECTOR_Composite:
         case DRM_MODE_CONNECTOR_9PinDIN:
+                if (radeon_tv == 1) {
+                        drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
+                        drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
+                }
                 break;
         case DRM_MODE_CONNECTOR_LVDS:
                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
@@ -522,10 +662,7 @@ radeon_add_legacy_connector(struct drm_device *dev,
         uint32_t subpixel_order = SubPixelNone;
 
         /* fixme - tv/cv/din */
-        if ((connector_type == DRM_MODE_CONNECTOR_Unknown) ||
-            (connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
-            (connector_type == DRM_MODE_CONNECTOR_Composite) ||
-            (connector_type == DRM_MODE_CONNECTOR_9PinDIN))
+        if (connector_type == DRM_MODE_CONNECTOR_Unknown)
                 return;
 
         /* see if we already added it */
@@ -578,6 +715,10 @@ radeon_add_legacy_connector(struct drm_device *dev,
         case DRM_MODE_CONNECTOR_SVIDEO:
         case DRM_MODE_CONNECTOR_Composite:
         case DRM_MODE_CONNECTOR_9PinDIN:
+                if (radeon_tv == 1) {
+                        drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
+                        drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
+                }
                 break;
         case DRM_MODE_CONNECTOR_LVDS:
                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);