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 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
  33 {
  34         int enc_id = connector->encoder_ids[0];
  35         struct drm_mode_object *obj;
  36         struct drm_encoder *encoder;
  37
  38         /* pick the encoder ids */
  39         if (enc_id) {
  40                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
  41                 if (!obj)
  42                         return NULL;
  43                 encoder = obj_to_encoder(obj);
  44                 return encoder;
  45         }
  46         return NULL;
  47 }
  48
  49 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
  50 {
  51         struct drm_device *dev = encoder->dev;
  52         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  53         struct drm_display_mode *mode = NULL;
  54
  55         if (radeon_encoder->panel_xres != 0 &&
  56             radeon_encoder->panel_yres != 0 &&
  57             radeon_encoder->dotclock != 0) {
  58                 mode = drm_mode_create(dev);
  59
  60                 mode->hdisplay = radeon_encoder->panel_xres;
  61                 mode->vdisplay = radeon_encoder->panel_yres;
  62
  63                 mode->htotal = mode->hdisplay + radeon_encoder->hblank;
  64                 mode->hsync_start = mode->hdisplay + radeon_encoder->hoverplus;
  65                 mode->hsync_end = mode->hsync_start + radeon_encoder->hsync_width;
  66                 mode->vtotal = mode->vdisplay + radeon_encoder->vblank;
  67                 mode->vsync_start = mode->vdisplay + radeon_encoder->voverplus;
  68                 mode->vsync_end = mode->vsync_start + radeon_encoder->vsync_width;
  69                 mode->clock = radeon_encoder->dotclock;
  70                 mode->flags = 0;
  71
  72                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  73
  74                 DRM_DEBUG("Adding native panel mode %dx%d\n",
  75                           radeon_encoder->panel_xres, radeon_encoder->panel_yres);
  76         }
  77         return mode;
  78 }
  79
  80 static int radeon_lvds_get_modes(struct drm_connector *connector)
  81 {
  82         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  83         struct drm_encoder *encoder;
  84         int ret = 0;
  85         struct edid *edid;
  86         struct drm_display_mode *mode;
  87
  88         if (radeon_connector->ddc_bus) {
  89                 radeon_i2c_do_lock(radeon_connector, 1);
  90                 edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
  91                 radeon_i2c_do_lock(radeon_connector, 0);
  92                 if (edid) {
  93                         drm_mode_connector_update_edid_property(&radeon_connector->base, edid);
  94                         ret = drm_add_edid_modes(&radeon_connector->base, edid);
  95                         kfree(edid);
  96                         return ret;
  97                 }
  98         }
  99
 100         encoder = radeon_best_single_encoder(connector);
 101         if (!encoder)
 102                 return connector_status_disconnected;
 103         /* we have no EDID modes */
 104         mode = radeon_fp_native_mode(encoder);
 105         if (mode) {
 106                 ret = 1;
 107                 drm_mode_probed_add(connector, mode);
 108         }
 109         return ret;
 110 }
 111
 112 static int radeon_lvds_mode_valid(struct drm_connector *connector,
 113                                   struct drm_display_mode *mode)
 114 {
 115         return MODE_OK;
 116 }
 117
 118 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
 119 {
 120         // check acpi lid status ???
 121         return connector_status_connected;
 122 }
 123
 124 static void radeon_connector_destroy(struct drm_connector *connector)
 125 {
 126         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 127
 128         if (radeon_connector->ddc_bus)
 129                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 130         drm_sysfs_connector_remove(connector);
 131         drm_connector_cleanup(connector);
 132         kfree(connector);
 133 }
 134
 135 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
 136         .get_modes = radeon_lvds_get_modes,
 137         .mode_valid = radeon_lvds_mode_valid,
 138         .best_encoder = radeon_best_single_encoder,
 139 };
 140
 141 struct drm_connector_funcs radeon_lvds_connector_funcs = {
 142         .detect = radeon_lvds_detect,
 143         .fill_modes = drm_helper_probe_single_connector_modes,
 144         .destroy = radeon_connector_destroy,
 145 };
 146
 147 static int radeon_vga_get_modes(struct drm_connector *connector)
 148 {
 149         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 150         int ret;
 151
 152         ret = radeon_ddc_get_modes(radeon_connector);
 153
 154         return ret;
 155 }
 156
 157 static int radeon_vga_mode_valid(struct drm_connector *connector,
 158                                   struct drm_display_mode *mode)
 159 {
 160
 161         return MODE_OK;
 162 }
 163
 164 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
 165 {
 166         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 167         struct drm_encoder *encoder;
 168         struct drm_encoder_helper_funcs *encoder_funcs;
 169         bool ret;
 170
 171         radeon_i2c_do_lock(radeon_connector, 1);
 172         ret = radeon_ddc_probe(radeon_connector);
 173         radeon_i2c_do_lock(radeon_connector, 0);
 174         if (ret)
 175                 return connector_status_connected;
 176
 177         /* if EDID fails to a load detect */
 178         encoder = radeon_best_single_encoder(connector);
 179         if (!encoder)
 180                 return connector_status_disconnected;
 181
 182         encoder_funcs = encoder->helper_private;
 183         return encoder_funcs->detect(encoder, connector);
 184 }
 185
 186 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
 187         .get_modes = radeon_vga_get_modes,
 188         .mode_valid = radeon_vga_mode_valid,
 189         .best_encoder = radeon_best_single_encoder,
 190 };
 191
 192 struct drm_connector_funcs radeon_vga_connector_funcs = {
 193         .detect = radeon_vga_detect,
 194         .fill_modes = drm_helper_probe_single_connector_modes,
 195         .destroy = radeon_connector_destroy,
 196 };
 197
 198
 199 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
 200 {
 201         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 202         struct drm_encoder *encoder;
 203         struct drm_encoder_helper_funcs *encoder_funcs;
 204         struct drm_mode_object *obj;
 205         int i;
 206         enum drm_connector_status ret;
 207         bool dret;
 208
 209         radeon_i2c_do_lock(radeon_connector, 1);
 210         dret = radeon_ddc_probe(radeon_connector);
 211         radeon_i2c_do_lock(radeon_connector, 0);
 212         if (dret)
 213                 return connector_status_connected;
 214
 215         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 216                 if (connector->encoder_ids[i] == 0)
 217                         break;
 218
 219                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 220                 if (!obj)
 221                         continue;
 222
 223                 encoder = obj_to_encoder(obj);
 224
 225                 encoder_funcs = encoder->helper_private;
 226                 if (encoder_funcs->detect) {
 227                         ret = encoder_funcs->detect(encoder, connector);
 228                         if (ret == connector_status_connected) {
 229                                 radeon_connector->use_digital = 0;
 230                                 return ret;
 231                         }
 232                 }
 233         }
 234         return connector_status_disconnected;
 235 }
 236
 237 /* okay need to be smart in here about which encoder to pick */
 238 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
 239 {
 240         int enc_id = connector->encoder_ids[0];
 241         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 242         struct drm_mode_object *obj;
 243         struct drm_encoder *encoder;
 244         int i;
 245         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 246                 if (connector->encoder_ids[i] == 0)
 247                         break;
 248
 249                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 250                 if (!obj)
 251                         continue;
 252
 253                 encoder = obj_to_encoder(obj);
 254
 255                 if (radeon_connector->use_digital) {
 256                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
 257                                 return encoder;
 258                 } else {
 259                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
 260                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
 261                                 return encoder;
 262                 }
 263         }
 264
 265         /* see if we have a default encoder  TODO */
 266
 267         /* then check use digitial */
 268         /* pick the first one */
 269         if (enc_id) {
 270                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
 271                 if (!obj)
 272                         return NULL;
 273                 encoder = obj_to_encoder(obj);
 274                 return encoder;
 275         }
 276         return NULL;
 277 }
 278
 279 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
 280         .get_modes = radeon_vga_get_modes,
 281         .mode_valid = radeon_vga_mode_valid,
 282         .best_encoder = radeon_dvi_encoder,
 283 };
 284
 285 struct drm_connector_funcs radeon_dvi_connector_funcs = {
 286         .detect = radeon_dvi_detect,
 287         .fill_modes = drm_helper_probe_single_connector_modes,
 288         .destroy = radeon_connector_destroy,
 289 };
 290
 291
 292 static struct connector_funcs {
 293         int conn_id;
 294         struct drm_connector_funcs *connector_funcs;
 295         struct drm_connector_helper_funcs *helper_funcs;
 296         int conn_type;
 297         char *i2c_id;
 298 } connector_fns[] = {
 299         { CONNECTOR_NONE, NULL, NULL, DRM_MODE_CONNECTOR_Unknown },
 300         { CONNECTOR_VGA, &radeon_vga_connector_funcs, &radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA , "VGA"},
 301         { CONNECTOR_LVDS, &radeon_lvds_connector_funcs, &radeon_lvds_connector_helper_funcs, DRM_MODE_CONNECTOR_LVDS, "LVDS" },
 302         { CONNECTOR_DVI_A, &radeon_vga_connector_funcs, &radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_DVIA, "DVI" },
 303         { CONNECTOR_DVI_I, &radeon_dvi_connector_funcs, &radeon_dvi_connector_helper_funcs, DRM_MODE_CONNECTOR_DVII, "DVI" },
 304
 305 #if 0
 306         { CONNECTOR_DVI_D, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 307
 308         { CONNECTOR_STV, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 309         { CONNECTOR_CTV, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 310         { CONNECTOR_DIGITAL, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 311         { CONNECTOR_SCART, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 312
 313         { CONNECTOR_HDMI_TYPE_A, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 314         { CONNECTOR_HDMI_TYPE_B, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 315         { CONNECTOR_HDMI_TYPE_B, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 316         { CONNECTOR_HDMI_TYPE_B, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 317         { CONNECTOR_DIN, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 318         { CONNECTOR_DISPLAY_PORT, radeon_vga_connector_funcs, radeon_vga_connector_helper_funcs, DRM_MODE_CONNECTOR_VGA },
 319 #endif
 320 };
 321
 322 struct drm_connector *radeon_connector_add(struct drm_device *dev, int bios_index)
 323 {
 324         struct radeon_connector *radeon_connector;
 325         struct drm_radeon_private *dev_priv = dev->dev_private;
 326         struct radeon_mode_info *mode_info = &dev_priv->mode_info;
 327         struct drm_connector *connector;
 328         int table_idx;
 329
 330         for (table_idx = 0; table_idx < ARRAY_SIZE(connector_fns); table_idx++) {
 331                 if (connector_fns[table_idx].conn_id == mode_info->bios_connector[bios_index].connector_type)
 332                         break;
 333         }
 334
 335         if (table_idx == ARRAY_SIZE(connector_fns))
 336                 return NULL;
 337
 338         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
 339         if (!radeon_connector) {
 340                 return NULL;
 341         }
 342
 343         connector = &radeon_connector->base;
 344
 345         drm_connector_init(dev, &radeon_connector->base, connector_fns[table_idx].connector_funcs,
 346                            connector_fns[table_idx].conn_type);
 347
 348         drm_connector_helper_add(&radeon_connector->base, connector_fns[table_idx].helper_funcs);
 349
 350         if (mode_info->bios_connector[bios_index].ddc_i2c.valid) {
 351                 radeon_connector->ddc_bus = radeon_i2c_create(dev, &mode_info->bios_connector[bios_index].ddc_i2c,
 352                                                               connector_fns[table_idx].i2c_id);
 353                 if (!radeon_connector->ddc_bus)
 354                         goto failed;
 355         }
 356
 357         drm_sysfs_connector_add(connector);
 358         return connector;
 359
 360
 361 failed:
 362         if (radeon_connector->ddc_bus)
 363                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 364         drm_connector_cleanup(connector);
 365         kfree(connector);
 366         return NULL;
 367 }