linux-core/radeon_connectors.c

   1 /*
   2  * Copyright 2007-8 Advanced Micro Devices, Inc.
   3  * Copyright 2008 Red Hat Inc.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors: Dave Airlie
  24  *          Alex Deucher
  25  */
  26 #include "drmP.h"
  27 #include "drm_edid.h"
  28 #include "drm_crtc_helper.h"
  29 #include "radeon_drm.h"
  30 #include "radeon_drv.h"
  31
  32 static int radeon_lvds_get_modes(struct drm_connector *connector)
  33 {
  34         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  35         struct drm_encoder *lvds_encoder;
  36         int ret = 0;
  37         struct edid *edid;
  38
  39         radeon_i2c_do_lock(radeon_connector, 1);
  40         edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
  41         radeon_i2c_do_lock(radeon_connector, 0);
  42         if (edid) {
  43                 drm_mode_connector_update_edid_property(&radeon_connector->base, edid);
  44                 ret = drm_add_edid_modes(&radeon_connector->base, edid);
  45                 kfree(edid);
  46                 return ret;
  47         }
  48
  49 #if 0
  50         lvds_encoder = radeon_best_single_encoder(connector);
  51
  52         if (!lvds_encoder)
  53                 return ret;
  54
  55         radeon_encoder_update_panel_size(lvds_encoder, connector);
  56 #endif
  57         return ret;
  58 }
  59
  60 static int radeon_lvds_mode_valid(struct drm_connector *connector,
  61                                   struct drm_display_mode *mode)
  62 {
  63
  64         return MODE_OK;
  65 }
  66
  67 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
  68 {
  69         // check acpi lid status ???
  70         return connector_status_connected;
  71 }
  72
  73
  74
  75 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
  76 {
  77         int enc_id = connector->encoder_ids[0];
  78         struct drm_mode_object *obj;
  79         struct drm_encoder *encoder;
  80
  81         /* pick the encoder ids */
  82         if (enc_id) {
  83                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
  84                 if (!obj)
  85                         return NULL;
  86                 encoder = obj_to_encoder(obj);
  87                 return encoder;
  88         }
  89         return NULL;
  90 }
  91
  92 static void radeon_connector_destroy(struct drm_connector *connector)
  93 {
  94         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  95
  96         if (radeon_connector->ddc_bus)
  97                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  98         drm_sysfs_connector_remove(connector);
  99         drm_connector_cleanup(connector);
 100         kfree(connector);
 101 }
 102
 103 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
 104         .get_modes = radeon_lvds_get_modes,
 105         .mode_valid = radeon_lvds_mode_valid,
 106         .best_encoder = radeon_best_single_encoder,
 107 };
 108
 109 struct drm_connector_funcs radeon_lvds_connector_funcs = {
 110         .detect = radeon_lvds_detect,
 111         .fill_modes = drm_helper_probe_single_connector_modes,
 112         .destroy = radeon_connector_destroy,
 113 };
 114
 115 static int radeon_vga_get_modes(struct drm_connector *connector)
 116 {
 117         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 118         int ret;
 119
 120         ret = radeon_ddc_get_modes(radeon_connector);
 121
 122         return ret;
 123 }
 124
 125 static int radeon_vga_mode_valid(struct drm_connector *connector,
 126                                   struct drm_display_mode *mode)
 127 {
 128
 129         return MODE_OK;
 130 }
 131
 132 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
 133 {
 134         struct edid *edid;
 135         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 136         struct drm_encoder *encoder;
 137         struct drm_encoder_helper_funcs *encoder_funcs;
 138
 139         radeon_i2c_do_lock(radeon_connector, 1);
 140         edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 141         radeon_i2c_do_lock(radeon_connector, 0);
 142         if (edid) {
 143                 kfree(edid);
 144                 return connector_status_connected;
 145         }
 146
 147         /* if EDID fails to a load detect */
 148         encoder = radeon_best_single_encoder(connector);
 149         if (!encoder)
 150                 return connector_status_disconnected;
 151
 152         encoder_funcs = encoder->helper_private;
 153         return encoder_funcs->detect(encoder, connector);
 154 }
 155
 156 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
 157         .get_modes = radeon_vga_get_modes,
 158         .mode_valid = radeon_vga_mode_valid,
 159         .best_encoder = radeon_best_single_encoder,
 160 };
 161
 162 struct drm_connector_funcs radeon_vga_connector_funcs = {
 163         .detect = radeon_vga_detect,
 164         .fill_modes = drm_helper_probe_single_connector_modes,
 165         .destroy = radeon_connector_destroy,
 166 };
 167
 168
 169 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
 170 {
 171         struct edid *edid;
 172         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 173         struct drm_encoder *encoder;
 174         struct drm_encoder_helper_funcs *encoder_funcs;
 175         struct drm_mode_object *obj;
 176         int i;
 177         enum drm_connector_status ret;
 178
 179         radeon_i2c_do_lock(radeon_connector, 1);
 180         edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 181         radeon_i2c_do_lock(radeon_connector, 0);
 182         if (edid) {
 183                 /* if the monitor is digital - set the bits */
 184                 if (edid->digital)
 185                         radeon_connector->use_digital = 1;
 186                 else
 187                         radeon_connector->use_digital = 0;
 188
 189                 kfree(edid);
 190                 return connector_status_connected;
 191         }
 192
 193         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 194                 if (connector->encoder_ids[i] == 0)
 195                         break;
 196
 197                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 198                 if (!obj)
 199                         continue;
 200
 201                 encoder = obj_to_encoder(obj);
 202
 203                 encoder_funcs = encoder->helper_private;
 204                 if (encoder_funcs->detect) {
 205                         ret = encoder_funcs->detect(encoder, connector);
 206                         if (ret == connector_status_connected) {
 207                                 radeon_connector->use_digital = 0;
 208                                 return ret;
 209                         }
 210                 }
 211         }
 212         return connector_status_disconnected;
 213 }
 214
 215 /* okay need to be smart in here about which encoder to pick */
 216 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
 217 {
 218         int enc_id = connector->encoder_ids[0];
 219         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 220         struct drm_mode_object *obj;
 221         struct drm_encoder *encoder;
 222         int i;
 223         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 224                 if (connector->encoder_ids[i] == 0)
 225                         break;
 226
 227                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 228                 if (!obj)
 229                         continue;
 230
 231                 encoder = obj_to_encoder(obj);
 232
 233                 if (radeon_connector->use_digital) {
 234                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
 235                                 return encoder;
 236                 } else {
 237                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
 238                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
 239                                 return encoder;
 240                 }
 241         }
 242
 243         /* see if we have a default encoder  TODO */
 244
 245         /* then check use digitial */
 246         /* pick the first one */
 247         if (enc_id) {
 248                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
 249                 if (!obj)
 250                         return NULL;
 251                 encoder = obj_to_encoder(obj);
 252                 return encoder;
 253         }
 254         return NULL;
 255 }
 256
 257 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
 258         .get_modes = radeon_vga_get_modes,
 259         .mode_valid = radeon_vga_mode_valid,
 260         .best_encoder = radeon_dvi_encoder,
 261 };
 262
 263 struct drm_connector_funcs radeon_dvi_connector_funcs = {
 264         .detect = radeon_dvi_detect,
 265         .fill_modes = drm_helper_probe_single_connector_modes,
 266         .destroy = radeon_connector_destroy,
 267 };
 268
 269
 270 static struct connector_funcs {
 271         int conn_id;
 272         struct drm_connector_funcs *connector_funcs;
 273         struct drm_connector_helper_funcs *helper_funcs;
 274         int conn_type;
 275         char *i2c_id;
 276 } connector_fns[] = {
 277         { CONNECTOR_NONE, NULL, NULL, DRM_MODE_CONNECTOR_Unknown },
 278         { CONNECTOR_VGA, &radeon_vga_connector_funcs, &radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA , "VGA"},
 279         { CONNECTOR_LVDS, &radeon_lvds_connector_funcs, &radeon_lvds_connector_helper_funcs, DRM_MODE_CONNECTOR_LVDS, "LVDS" },
 280         { CONNECTOR_DVI_A, &radeon_vga_connector_funcs, &radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_DVIA, "DVI" },
 281         { CONNECTOR_DVI_I, &radeon_dvi_connector_funcs, &radeon_dvi_connector_helper_funcs, DRM_MODE_CONNECTOR_DVII, "DVI" },
 282
 283 #if 0
 284         { CONNECTOR_DVI_D, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 285
 286         { CONNECTOR_STV, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 287         { CONNECTOR_CTV, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 288         { CONNECTOR_DIGITAL, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 289         { CONNECTOR_SCART, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 290
 291         { CONNECTOR_HDMI_TYPE_A, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 292         { CONNECTOR_HDMI_TYPE_B, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 293         { CONNECTOR_HDMI_TYPE_B, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 294         { CONNECTOR_HDMI_TYPE_B, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 295         { CONNECTOR_DIN, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 296         { CONNECTOR_DISPLAY_PORT, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 297 #endif
 298 };
 299
 300 struct drm_connector *radeon_connector_add(struct drm_device *dev, int bios_index)
 301 {
 302         struct radeon_connector *radeon_connector;
 303         struct drm_radeon_private *dev_priv = dev->dev_private;
 304         struct radeon_mode_info *mode_info = &dev_priv->mode_info;
 305         struct drm_connector *connector;
 306         int table_idx;
 307
 308         for (table_idx = 0; table_idx < ARRAY_SIZE(connector_fns); table_idx++) {
 309                 if (connector_fns[table_idx].conn_id == mode_info->bios_connector[bios_index].connector_type)
 310                         break;
 311         }
 312
 313         if (table_idx == ARRAY_SIZE(connector_fns))
 314                 return NULL;
 315
 316         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
 317         if (!radeon_connector) {
 318                 return NULL;
 319         }
 320
 321         connector = &radeon_connector->base;
 322
 323         drm_connector_init(dev, &radeon_connector->base, connector_fns[table_idx].connector_funcs,
 324                            connector_fns[table_idx].conn_type);
 325
 326         drm_connector_helper_add(&radeon_connector->base, connector_fns[table_idx].helper_funcs);
 327
 328         if (mode_info->bios_connector[bios_index].ddc_i2c.valid) {
 329                 radeon_connector->ddc_bus = radeon_i2c_create(dev, &mode_info->bios_connector[bios_index].ddc_i2c,
 330                                                               connector_fns[table_idx].i2c_id);
 331                 if (!radeon_connector->ddc_bus)
 332                         goto failed;
 333         }
 334
 335         drm_sysfs_connector_add(connector);
 336         return connector;
 337
 338
 339 failed:
 340         if (radeon_connector->ddc_bus)
 341                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 342         drm_connector_cleanup(connector);
 343         kfree(connector);
 344         return NULL;
 345 }