linux-core/radeon_encoders.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_crtc_helper.h"
  28 #include "radeon_drm.h"
  29 #include "radeon_drv.h"
  30
  31 extern int atom_debug;
  32
  33 void radeon_rmx_mode_fixup(struct drm_encoder *encoder,
  34                            struct drm_display_mode *mode,
  35                            struct drm_display_mode *adjusted_mode)
  36 {
  37         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  38         if (mode->hdisplay < radeon_encoder->panel_xres ||
  39             mode->vdisplay < radeon_encoder->panel_yres) {
  40                 radeon_encoder->flags |= RADEON_USE_RMX;
  41                 adjusted_mode->hdisplay = radeon_encoder->panel_xres;
  42                 adjusted_mode->vdisplay = radeon_encoder->panel_yres;
  43                 adjusted_mode->htotal = radeon_encoder->panel_xres + radeon_encoder->hblank;
  44                 adjusted_mode->hsync_start = radeon_encoder->panel_xres + radeon_encoder->hoverplus;
  45                 adjusted_mode->hsync_end = adjusted_mode->hsync_start + radeon_encoder->hsync_width;
  46                 adjusted_mode->vtotal = radeon_encoder->panel_yres + radeon_encoder->vblank;
  47                 adjusted_mode->vsync_start = radeon_encoder->panel_yres + radeon_encoder->voverplus;
  48                 adjusted_mode->vsync_end = adjusted_mode->vsync_start + radeon_encoder->vsync_width;
  49                 /* update crtc values */
  50                 drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
  51                 /* adjust crtc values */
  52                 adjusted_mode->crtc_hdisplay = radeon_encoder->panel_xres;
  53                 adjusted_mode->crtc_vdisplay = radeon_encoder->panel_yres;
  54                 adjusted_mode->crtc_htotal = adjusted_mode->crtc_hdisplay + radeon_encoder->hblank;
  55                 adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hdisplay + radeon_encoder->hoverplus;
  56                 adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_start + radeon_encoder->hsync_width;
  57                 adjusted_mode->crtc_vtotal = adjusted_mode->crtc_vdisplay + radeon_encoder->vblank;
  58                 adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + radeon_encoder->voverplus;
  59                 adjusted_mode->crtc_vsync_end = adjusted_mode->crtc_vsync_start + radeon_encoder->vsync_width;
  60         } else {
  61                 adjusted_mode->htotal = radeon_encoder->panel_xres + radeon_encoder->hblank;
  62                 adjusted_mode->hsync_start = radeon_encoder->panel_xres + radeon_encoder->hoverplus;
  63                 adjusted_mode->hsync_end = adjusted_mode->hsync_start + radeon_encoder->hsync_width;
  64                 adjusted_mode->vtotal = radeon_encoder->panel_yres + radeon_encoder->vblank;
  65                 adjusted_mode->vsync_start = radeon_encoder->panel_yres + radeon_encoder->voverplus;
  66                 adjusted_mode->vsync_end = adjusted_mode->vsync_start + radeon_encoder->vsync_width;
  67                 /* update crtc values */
  68                 drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
  69                 /* adjust crtc values */
  70                 adjusted_mode->crtc_htotal = adjusted_mode->crtc_hdisplay + radeon_encoder->hblank;
  71                 adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hdisplay + radeon_encoder->hoverplus;
  72                 adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_start + radeon_encoder->hsync_width;
  73                 adjusted_mode->crtc_vtotal = adjusted_mode->crtc_vdisplay + radeon_encoder->vblank;
  74                 adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + radeon_encoder->voverplus;
  75                 adjusted_mode->crtc_vsync_end = adjusted_mode->crtc_vsync_start + radeon_encoder->vsync_width;
  76         }
  77         adjusted_mode->clock = radeon_encoder->dotclock;
  78         adjusted_mode->flags = radeon_encoder->flags;
  79 }
  80
  81
  82 static int atom_dac_find_atom_type(struct radeon_encoder *radeon_encoder, struct drm_connector *connector)
  83 {
  84         struct drm_device *dev = radeon_encoder->base.dev;
  85         struct drm_connector *connector_find;
  86         int atom_type = -1;
  87
  88         if (!connector) {
  89                 list_for_each_entry(connector_find, &dev->mode_config.connector_list, head) {
  90                         if (connector_find->encoder == &radeon_encoder->base)
  91                                 connector = connector_find;
  92                 }
  93         }
  94         if (connector) {
  95                 /* look for the encoder in the connector list -
  96                    check if we the DAC is enabled on a VGA or STV/CTV or CV connector */
  97                 /* work out the ATOM_DEVICE bits */
  98                 switch (connector->connector_type) {
  99                 case CONNECTOR_VGA:
 100                 case CONNECTOR_DVI_I:
 101                 case CONNECTOR_DVI_A:
 102                         if (radeon_encoder->atom_device & ATOM_DEVICE_CRT1_SUPPORT)
 103                                 atom_type = ATOM_DEVICE_CRT1_INDEX;
 104                         else if (radeon_encoder->atom_device & ATOM_DEVICE_CRT2_SUPPORT)
 105                                 atom_type = ATOM_DEVICE_CRT2_INDEX;
 106                         break;
 107                 case CONNECTOR_STV:
 108                 case CONNECTOR_CTV:
 109                         if (radeon_encoder->atom_device & ATOM_DEVICE_TV1_SUPPORT)
 110                                 atom_type = ATOM_DEVICE_TV1_INDEX;
 111                         break;
 112                 case CONNECTOR_DIN:
 113                         if (radeon_encoder->atom_device & ATOM_DEVICE_TV1_SUPPORT)
 114                                 atom_type = ATOM_DEVICE_TV1_INDEX;
 115                         if (radeon_encoder->atom_device & ATOM_DEVICE_CV_SUPPORT)
 116                                 atom_type = ATOM_DEVICE_CV_INDEX;
 117                         break;
 118                 }
 119         }
 120
 121         return atom_type;
 122 }
 123
 124 /* LVTMA encoder for LVDS usage */
 125 static void atombios_display_device_control(struct drm_encoder *encoder, int index, uint8_t state)
 126 {
 127         struct drm_device *dev = encoder->dev;
 128         struct drm_radeon_private *dev_priv = dev->dev_private;
 129         DISPLAY_DEVICE_OUTPUT_CONTROL_PS_ALLOCATION args;
 130
 131         memset(&args, 0, sizeof(args));
 132         args.ucAction = state;
 133
 134         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 135 }
 136
 137 static void atombios_scaler_setup(struct drm_encoder *encoder, struct drm_display_mode *mode)
 138 {
 139         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 140         struct drm_device *dev = encoder->dev;
 141         struct drm_radeon_private *dev_priv = dev->dev_private;
 142         struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
 143         ENABLE_SCALER_PS_ALLOCATION args;
 144         int index = GetIndexIntoMasterTable(COMMAND, EnableScaler);
 145
 146         memset(&args, 0, sizeof(args));
 147         args.ucScaler = radeon_crtc->crtc_id;
 148
 149         if (radeon_encoder->flags & RADEON_USE_RMX) {
 150                 if (radeon_encoder->rmx_type == RMX_FULL)
 151                         args.ucEnable = ATOM_SCALER_EXPANSION;
 152                 else if (radeon_encoder->rmx_type == RMX_CENTER)
 153                         args.ucEnable = ATOM_SCALER_CENTER;
 154         } else
 155                 args.ucEnable = ATOM_SCALER_DISABLE;
 156
 157         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 158 }
 159
 160 void atombios_set_crtc_source(struct drm_encoder *encoder, int source)
 161 {
 162         int index = GetIndexIntoMasterTable(COMMAND, SelectCRTC_Source);
 163         struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
 164         struct drm_radeon_private *dev_priv = encoder->dev->dev_private;
 165         uint8_t frev, crev;
 166         SELECT_CRTC_SOURCE_PS_ALLOCATION crtc_src_param;
 167         SELECT_CRTC_SOURCE_PARAMETERS_V2 crtc_src_param2;
 168         uint32_t *param = NULL;
 169
 170         atom_parse_cmd_header(dev_priv->mode_info.atom_context, index, &frev, &crev);
 171         switch (frev) {
 172         case 1: {
 173                 switch (crev) {
 174                 case 0:
 175                 case 1:
 176                 default:
 177                         memset(&crtc_src_param, 0, sizeof(crtc_src_param));
 178                         crtc_src_param.ucCRTC = radeon_crtc->crtc_id;
 179                         crtc_src_param.ucDevice = source;
 180                         param = (uint32_t *)&crtc_src_param;
 181                         break;
 182                 case 2:
 183                         memset(&crtc_src_param2, 0, sizeof(crtc_src_param2));
 184                         crtc_src_param2.ucCRTC = radeon_crtc->crtc_id;
 185                         crtc_src_param2.ucEncoderID = source;
 186                         switch (source) {
 187                         case ATOM_DEVICE_CRT1_INDEX:
 188                         case ATOM_DEVICE_CRT2_INDEX:
 189                                 crtc_src_param2.ucEncodeMode = ATOM_ENCODER_MODE_CRT;
 190                                 break;
 191                         case ATOM_DEVICE_DFP1_INDEX:
 192                         case ATOM_DEVICE_DFP2_INDEX:
 193                         case ATOM_DEVICE_DFP3_INDEX:
 194                                 crtc_src_param2.ucEncodeMode = ATOM_ENCODER_MODE_DVI;
 195                                 // TODO ENCODER MODE
 196                                 break;
 197                         case ATOM_DEVICE_LCD1_INDEX:
 198                                 crtc_src_param2.ucEncodeMode = ATOM_ENCODER_MODE_LVDS;
 199                                 break;
 200                         case ATOM_DEVICE_TV1_INDEX:
 201                                 crtc_src_param2.ucEncodeMode = ATOM_ENCODER_MODE_TV;
 202                                 break;
 203                         case ATOM_DEVICE_CV_INDEX:
 204                                 crtc_src_param2.ucEncodeMode = ATOM_ENCODER_MODE_CV;
 205                                 break;
 206                         }
 207                         param = (uint32_t *)&crtc_src_param2;
 208                         break;
 209                 }
 210         }
 211                 break;
 212         default:
 213                 return;
 214         }
 215
 216         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)param);
 217
 218 }
 219
 220 static void radeon_dfp_disable_dither(struct drm_encoder *encoder, int device)
 221 {
 222         struct drm_device *dev = encoder->dev;
 223         struct drm_radeon_private *dev_priv = dev->dev_private;
 224
 225         switch (device) {
 226         case ATOM_DEVICE_DFP1_INDEX:
 227                 RADEON_WRITE(AVIVO_TMDSA_BIT_DEPTH_CONTROL, 0); /* TMDSA */
 228                 break;
 229         case ATOM_DEVICE_DFP2_INDEX:
 230                 if ((dev_priv->chip_family == CHIP_RS600) ||
 231                     (dev_priv->chip_family == CHIP_RS690) ||
 232                     (dev_priv->chip_family == CHIP_RS740))
 233                         RADEON_WRITE(AVIVO_DDIA_BIT_DEPTH_CONTROL, 0); /* DDIA */
 234                 else
 235                         RADEON_WRITE(AVIVO_DVOA_BIT_DEPTH_CONTROL, 0); /* DVO */
 236                 break;
 237                 /*case ATOM_DEVICE_LCD1_INDEX:*/ /* LVDS panels need dither enabled */
 238         case ATOM_DEVICE_DFP3_INDEX:
 239                 RADEON_WRITE(AVIVO_LVTMA_BIT_DEPTH_CONTROL, 0); /* LVTMA */
 240                 break;
 241         default:
 242                 break;
 243         }
 244 }
 245
 246
 247 static void radeon_lvtma_mode_set(struct drm_encoder *encoder,
 248                                   struct drm_display_mode *mode,
 249                                   struct drm_display_mode *adjusted_mode)
 250 {
 251         struct drm_device *dev = encoder->dev;
 252         struct drm_radeon_private *dev_priv = dev->dev_private;
 253         LVDS_ENCODER_CONTROL_PS_ALLOCATION args;
 254         int index = GetIndexIntoMasterTable(COMMAND, LVDSEncoderControl);
 255
 256         memset(&args, 0, sizeof(args));
 257         atombios_scaler_setup(encoder, mode);
 258         atombios_set_crtc_source(encoder, ATOM_DEVICE_LCD1_INDEX);
 259
 260         args.ucAction = 1;
 261         if (adjusted_mode->clock > 165000)
 262                 args.ucMisc = 1;
 263         else
 264                 args.ucMisc = 0;
 265         args.usPixelClock = cpu_to_le16(adjusted_mode->clock / 10);
 266
 267         printk("executing set LVDS encoder\n");
 268         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 269 }
 270
 271
 272 static void radeon_lvtma_dpms(struct drm_encoder *encoder, int mode)
 273 {
 274         struct drm_device *dev = encoder->dev;
 275         struct drm_radeon_private *dev_priv = dev->dev_private;
 276         struct radeon_crtc *radeon_crtc;
 277         int index = GetIndexIntoMasterTable(COMMAND, LCD1OutputControl);
 278         uint32_t bios_2_scratch, bios_3_scratch;
 279         int crtc_id = 0;
 280
 281         if (encoder->crtc) {
 282                 struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
 283                 crtc_id = radeon_crtc->crtc_id;
 284         }
 285
 286         if (dev_priv->chip_family >= CHIP_R600) {
 287                 bios_2_scratch = RADEON_READ(R600_BIOS_2_SCRATCH);
 288                 bios_3_scratch = RADEON_READ(R600_BIOS_3_SCRATCH);
 289         } else {
 290                 bios_2_scratch = RADEON_READ(RADEON_BIOS_2_SCRATCH);
 291                 bios_3_scratch = RADEON_READ(RADEON_BIOS_3_SCRATCH);
 292         }
 293
 294         bios_2_scratch &= ~ATOM_S3_LCD1_CRTC_ACTIVE;
 295         bios_3_scratch |= (crtc_id << 17);
 296
 297         switch(mode) {
 298         case DRM_MODE_DPMS_ON:
 299                 atombios_display_device_control(encoder, index, ATOM_ENABLE);
 300                 bios_2_scratch &= ~ATOM_S2_LCD1_DPMS_STATE;
 301                 bios_3_scratch |= ATOM_S3_LCD1_ACTIVE;
 302                 break;
 303         case DRM_MODE_DPMS_STANDBY:
 304         case DRM_MODE_DPMS_SUSPEND:
 305         case DRM_MODE_DPMS_OFF:
 306                 atombios_display_device_control(encoder, index, ATOM_DISABLE);
 307                 bios_2_scratch |= ATOM_S2_LCD1_DPMS_STATE;
 308                 bios_3_scratch &= ~ATOM_S3_LCD1_ACTIVE;
 309                 break;
 310         }
 311
 312         if (dev_priv->chip_family >= CHIP_R600) {
 313                 RADEON_WRITE(R600_BIOS_2_SCRATCH, bios_2_scratch);
 314                 RADEON_WRITE(R600_BIOS_3_SCRATCH, bios_3_scratch);
 315         } else {
 316                 RADEON_WRITE(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
 317                 RADEON_WRITE(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
 318         }
 319 }
 320
 321 static bool radeon_lvtma_mode_fixup(struct drm_encoder *encoder,
 322                                     struct drm_display_mode *mode,
 323                                     struct drm_display_mode *adjusted_mode)
 324 {
 325         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 326
 327         radeon_encoder->flags &= ~RADEON_USE_RMX;
 328
 329         if (radeon_encoder->rmx_type != RMX_OFF)
 330                 radeon_rmx_mode_fixup(encoder, mode, adjusted_mode);
 331
 332         return true;
 333 }
 334
 335 static void radeon_lvtma_prepare(struct drm_encoder *encoder)
 336 {
 337         radeon_atom_output_lock(encoder, true);
 338         radeon_lvtma_dpms(encoder, DRM_MODE_DPMS_OFF);
 339 }
 340
 341 static void radeon_lvtma_commit(struct drm_encoder *encoder)
 342 {
 343         radeon_lvtma_dpms(encoder, DRM_MODE_DPMS_ON);
 344         radeon_atom_output_lock(encoder, false);
 345 }
 346
 347 static const struct drm_encoder_helper_funcs radeon_atom_lvtma_helper_funcs = {
 348         .dpms = radeon_lvtma_dpms,
 349         .mode_fixup = radeon_lvtma_mode_fixup,
 350         .prepare = radeon_lvtma_prepare,
 351         .mode_set = radeon_lvtma_mode_set,
 352         .commit = radeon_lvtma_commit,
 353 };
 354
 355 void radeon_enc_destroy(struct drm_encoder *encoder)
 356 {
 357         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 358         drm_encoder_cleanup(encoder);
 359         kfree(radeon_encoder);
 360 }
 361
 362 static const struct drm_encoder_funcs radeon_atom_lvtma_enc_funcs = {
 363         .destroy = radeon_enc_destroy,
 364 };
 365
 366 struct drm_encoder *radeon_encoder_lvtma_add(struct drm_device *dev, int bios_index)
 367 {
 368         struct drm_radeon_private *dev_priv = dev->dev_private;
 369         struct radeon_mode_info *mode_info = &dev_priv->mode_info;
 370         struct radeon_encoder *radeon_encoder;
 371         struct drm_encoder *encoder;
 372         radeon_encoder = kzalloc(sizeof(struct radeon_encoder), GFP_KERNEL);
 373         if (!radeon_encoder) {
 374                 return NULL;
 375         }
 376
 377         encoder = &radeon_encoder->base;
 378
 379         /* Set LVTMA to only use crtc 0 */
 380         encoder->possible_crtcs = 0x1;
 381         encoder->possible_clones = 0;
 382         drm_encoder_init(dev, encoder, &radeon_atom_lvtma_enc_funcs,
 383                          DRM_MODE_ENCODER_LVDS);
 384
 385         drm_encoder_helper_add(encoder, &radeon_atom_lvtma_helper_funcs);
 386         radeon_encoder->atom_device = mode_info->bios_connector[bios_index].devices;
 387
 388         /* TODO get the LVDS info from the BIOS for panel size etc. */
 389         /* get the lvds info from the bios */
 390         radeon_atombios_get_lvds_info(radeon_encoder);
 391
 392         /* LVDS gets default RMX full scaling */
 393         radeon_encoder->rmx_type = RMX_FULL;
 394
 395         return encoder;
 396 }
 397
 398 static void radeon_atom_dac_dpms(struct drm_encoder *encoder, int mode)
 399 {
 400         struct drm_device *dev = encoder->dev;
 401         struct drm_radeon_private *dev_priv = dev->dev_private;
 402         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 403         struct radeon_crtc *radeon_crtc;
 404         int atom_type = -1;
 405         int index;
 406         uint32_t bios_2_scratch, bios_3_scratch;
 407         int crtc_id = 0;
 408
 409         if (encoder->crtc) {
 410                 radeon_crtc = to_radeon_crtc(encoder->crtc);
 411                 crtc_id = radeon_crtc->crtc_id;
 412         }
 413
 414         atom_type = atom_dac_find_atom_type(radeon_encoder, NULL);
 415         if (atom_type == -1)
 416                 return;
 417
 418         if (dev_priv->chip_family >= CHIP_R600) {
 419                 bios_2_scratch = RADEON_READ(R600_BIOS_2_SCRATCH);
 420                 bios_3_scratch = RADEON_READ(R600_BIOS_3_SCRATCH);
 421         } else {
 422                 bios_2_scratch = RADEON_READ(RADEON_BIOS_2_SCRATCH);
 423                 bios_3_scratch = RADEON_READ(RADEON_BIOS_3_SCRATCH);
 424         }
 425
 426         switch(atom_type) {
 427         case ATOM_DEVICE_CRT1_INDEX:
 428                 index = GetIndexIntoMasterTable(COMMAND, DAC1OutputControl);
 429                 bios_2_scratch &= ~ATOM_S3_CRT1_CRTC_ACTIVE;
 430                 bios_3_scratch |= (crtc_id << 16);
 431                 switch(mode) {
 432                 case DRM_MODE_DPMS_ON:
 433                         bios_2_scratch &= ~ATOM_S2_CRT1_DPMS_STATE;
 434                         bios_3_scratch |= ATOM_S3_CRT1_ACTIVE;
 435                         break;
 436                 case DRM_MODE_DPMS_STANDBY:
 437                 case DRM_MODE_DPMS_SUSPEND:
 438                 case DRM_MODE_DPMS_OFF:
 439                         bios_2_scratch |= ATOM_S2_CRT1_DPMS_STATE;
 440                         bios_3_scratch &= ~ATOM_S3_CRT1_ACTIVE;
 441                         break;
 442                 }
 443                 break;
 444         case ATOM_DEVICE_CRT2_INDEX:
 445                 index = GetIndexIntoMasterTable(COMMAND, DAC2OutputControl);
 446                 bios_2_scratch &= ~ATOM_S3_CRT2_CRTC_ACTIVE;
 447                 bios_3_scratch |= (crtc_id << 20);
 448                 switch(mode) {
 449                 case DRM_MODE_DPMS_ON:
 450                         bios_2_scratch &= ~ATOM_S2_CRT2_DPMS_STATE;
 451                         bios_3_scratch |= ATOM_S3_CRT2_ACTIVE;
 452                         break;
 453                 case DRM_MODE_DPMS_STANDBY:
 454                 case DRM_MODE_DPMS_SUSPEND:
 455                 case DRM_MODE_DPMS_OFF:
 456                         bios_2_scratch |= ATOM_S2_CRT2_DPMS_STATE;
 457                         bios_3_scratch &= ~ATOM_S3_CRT2_ACTIVE;
 458                         break;
 459                 }
 460                 break;
 461         case ATOM_DEVICE_TV1_INDEX:
 462                 index = GetIndexIntoMasterTable(COMMAND, TV1OutputControl);
 463                 bios_3_scratch &= ~ATOM_S3_TV1_CRTC_ACTIVE;
 464                 bios_3_scratch |= (crtc_id << 18);
 465                 switch(mode) {
 466                 case DRM_MODE_DPMS_ON:
 467                         bios_2_scratch &= ~ATOM_S2_TV1_DPMS_STATE;
 468                         bios_3_scratch |= ATOM_S3_TV1_ACTIVE;
 469                         break;
 470                 case DRM_MODE_DPMS_STANDBY:
 471                 case DRM_MODE_DPMS_SUSPEND:
 472                 case DRM_MODE_DPMS_OFF:
 473                         bios_2_scratch |= ATOM_S2_TV1_DPMS_STATE;
 474                         bios_3_scratch &= ~ATOM_S3_TV1_ACTIVE;
 475                         break;
 476                 }
 477                 break;
 478         case ATOM_DEVICE_CV_INDEX:
 479                 index = GetIndexIntoMasterTable(COMMAND, CV1OutputControl);
 480                 bios_2_scratch &= ~ATOM_S3_CV_CRTC_ACTIVE;
 481                 bios_3_scratch |= (crtc_id << 24);
 482                 switch(mode) {
 483                 case DRM_MODE_DPMS_ON:
 484                         bios_2_scratch &= ~ATOM_S2_CV_DPMS_STATE;
 485                         bios_3_scratch |= ATOM_S3_CV_ACTIVE;
 486                         break;
 487                 case DRM_MODE_DPMS_STANDBY:
 488                 case DRM_MODE_DPMS_SUSPEND:
 489                 case DRM_MODE_DPMS_OFF:
 490                         bios_2_scratch |= ATOM_S2_CV_DPMS_STATE;
 491                         bios_3_scratch &= ~ATOM_S3_CV_ACTIVE;
 492                         break;
 493                 }
 494                 break;
 495         default:
 496                 return;
 497         }
 498
 499         switch(mode) {
 500         case DRM_MODE_DPMS_ON:
 501                 atombios_display_device_control(encoder, index, ATOM_ENABLE);
 502                 break;
 503         case DRM_MODE_DPMS_STANDBY:
 504         case DRM_MODE_DPMS_SUSPEND:
 505         case DRM_MODE_DPMS_OFF:
 506                 atombios_display_device_control(encoder, index, ATOM_DISABLE);
 507                 break;
 508         }
 509
 510         if (dev_priv->chip_family >= CHIP_R600) {
 511                 RADEON_WRITE(R600_BIOS_2_SCRATCH, bios_2_scratch);
 512                 RADEON_WRITE(R600_BIOS_3_SCRATCH, bios_3_scratch);
 513         } else {
 514                 RADEON_WRITE(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
 515                 RADEON_WRITE(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
 516         }
 517 }
 518
 519 static bool radeon_atom_dac_mode_fixup(struct drm_encoder *encoder,
 520                                   struct drm_display_mode *mode,
 521                                   struct drm_display_mode *adjusted_mode)
 522 {
 523         return true;
 524 }
 525
 526 static void radeon_atom_dac_prepare(struct drm_encoder *encoder)
 527 {
 528         radeon_atom_output_lock(encoder, true);
 529         radeon_atom_dac_dpms(encoder, DRM_MODE_DPMS_OFF);
 530 }
 531
 532 static void radeon_atom_dac_commit(struct drm_encoder *encoder)
 533 {
 534         radeon_atom_dac_dpms(encoder, DRM_MODE_DPMS_ON);
 535         radeon_atom_output_lock(encoder, false);
 536 }
 537
 538 static int atombios_dac_setup(struct drm_encoder *encoder,
 539                               struct drm_display_mode *mode,
 540                               int atom_type)
 541 {
 542         struct drm_device *dev = encoder->dev;
 543         struct drm_radeon_private *dev_priv = dev->dev_private;
 544         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 545         DAC_ENCODER_CONTROL_PS_ALLOCATION args;
 546         int id = (radeon_encoder->type.dac == DAC_TVDAC);
 547         int index;
 548
 549         memset(&args, 0, sizeof(args));
 550         if (id == 0)
 551                 index = GetIndexIntoMasterTable(COMMAND, DAC1EncoderControl);
 552         else
 553                 index = GetIndexIntoMasterTable(COMMAND, DAC2EncoderControl);
 554
 555         args.ucAction = 1;
 556         args.usPixelClock = cpu_to_le16(mode->clock / 10);
 557         if ((atom_type == ATOM_DEVICE_CRT1_INDEX) ||
 558             (atom_type == ATOM_DEVICE_CRT2_INDEX))
 559                 args.ucDacStandard = id ? ATOM_DAC2_PS2 : ATOM_DAC1_PS2;
 560         else if (atom_type == ATOM_DEVICE_CV_INDEX)
 561                 args.ucDacStandard = id ? ATOM_DAC2_CV : ATOM_DAC1_CV;
 562         else if (atom_type == ATOM_DEVICE_TV1_INDEX)
 563                 args.ucDacStandard = id ? ATOM_DAC2_NTSC : ATOM_DAC1_NTSC;
 564         /* TODO PAL */
 565         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 566
 567         return 0;
 568 }
 569
 570 static int atombios_tv1_setup(struct drm_encoder *encoder,
 571                               struct drm_display_mode *mode,
 572                               int atom_type)
 573 {
 574         struct drm_device *dev = encoder->dev;
 575         struct drm_radeon_private *dev_priv = dev->dev_private;
 576         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 577         TV_ENCODER_CONTROL_PS_ALLOCATION args;
 578         int index = GetIndexIntoMasterTable(COMMAND, TVEncoderControl);
 579
 580         memset(&args, 0, sizeof(args));
 581         args.sTVEncoder.ucAction = 1;
 582         if (atom_type == ATOM_DEVICE_CV_INDEX)
 583                 args.sTVEncoder.ucTvStandard = ATOM_TV_CV;
 584         else {
 585                 // TODO PAL
 586                 args.sTVEncoder.ucTvStandard = ATOM_TV_NTSC;
 587         }
 588
 589         args.sTVEncoder.usPixelClock = cpu_to_le16(mode->clock / 10);
 590
 591         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 592         return 0;
 593 }
 594
 595 static void radeon_atom_dac_mode_set(struct drm_encoder *encoder,
 596                                      struct drm_display_mode *mode,
 597                                      struct drm_display_mode *adjusted_mode)
 598 {
 599         struct drm_device *dev = encoder->dev;
 600         struct drm_radeon_private *dev_priv = dev->dev_private;
 601         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 602         int atom_type = -1;
 603
 604         atom_type = atom_dac_find_atom_type(radeon_encoder, NULL);
 605         if (atom_type == -1)
 606                 return;
 607
 608         atombios_scaler_setup(encoder, mode);
 609         atombios_set_crtc_source(encoder, atom_type);
 610
 611         atombios_dac_setup(encoder, adjusted_mode, atom_type);
 612         if ((atom_type == ATOM_DEVICE_TV1_INDEX) ||
 613             (atom_type == ATOM_DEVICE_CV_INDEX))
 614                 atombios_tv1_setup(encoder, adjusted_mode, atom_type);
 615
 616 }
 617
 618 static bool atom_dac_load_detect(struct drm_encoder *encoder, int atom_devices)
 619 {
 620         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 621         struct drm_device *dev = encoder->dev;
 622         struct drm_radeon_private *dev_priv = dev->dev_private;
 623         DAC_LOAD_DETECTION_PS_ALLOCATION args;
 624         int index = GetIndexIntoMasterTable(COMMAND, DAC_LoadDetection);
 625
 626         memset(&args, 0, sizeof(args));
 627         args.sDacload.ucMisc = 0;
 628         args.sDacload.ucDacType = (radeon_encoder->type.dac == DAC_PRIMARY) ? ATOM_DAC_A : ATOM_DAC_B;
 629
 630         if (atom_devices & ATOM_DEVICE_CRT1_SUPPORT)
 631                 args.sDacload.usDeviceID = cpu_to_le16(ATOM_DEVICE_CRT1_SUPPORT);
 632         else if (atom_devices & ATOM_DEVICE_CRT2_SUPPORT)
 633                 args.sDacload.usDeviceID = cpu_to_le16(ATOM_DEVICE_CRT2_SUPPORT);
 634         else if (atom_devices & ATOM_DEVICE_CV_SUPPORT) {
 635                 args.sDacload.usDeviceID = cpu_to_le16(ATOM_DEVICE_CV_SUPPORT);
 636                 if (radeon_is_dce3(dev_priv))
 637                         args.sDacload.ucMisc = 1;
 638         } else if (atom_devices & ATOM_DEVICE_TV1_SUPPORT) {
 639                 args.sDacload.usDeviceID = cpu_to_le16(ATOM_DEVICE_TV1_SUPPORT);
 640                 if (radeon_is_dce3(dev_priv))
 641                         args.sDacload.ucMisc = 1;
 642         } else
 643                 return false;
 644
 645         DRM_DEBUG("writing %x %x\n", args.sDacload.usDeviceID, args.sDacload.ucDacType);
 646         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 647         return true;
 648 }
 649
 650 static enum drm_connector_status radeon_atom_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
 651 {
 652         struct drm_device *dev = encoder->dev;
 653         struct drm_radeon_private *dev_priv = dev->dev_private;
 654         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 655         int atom_type = -1;
 656         uint32_t bios_0_scratch;
 657
 658         atom_type = atom_dac_find_atom_type(radeon_encoder, connector);
 659         if (atom_type == -1) {
 660                 DRM_DEBUG("exit after find \n");
 661                 return connector_status_unknown;
 662         }
 663
 664         if(!atom_dac_load_detect(encoder, (1 << atom_type))) {
 665                 DRM_DEBUG("detect returned false \n");
 666                 return connector_status_unknown;
 667         }
 668
 669
 670         if (dev_priv->chip_family >= CHIP_R600)
 671                 bios_0_scratch = RADEON_READ(R600_BIOS_0_SCRATCH);
 672         else
 673                 bios_0_scratch = RADEON_READ(RADEON_BIOS_0_SCRATCH);
 674
 675         DRM_DEBUG("Bios 0 scratch %x\n", bios_0_scratch);
 676         if (radeon_encoder->atom_device & ATOM_DEVICE_CRT1_SUPPORT) {
 677                 if (bios_0_scratch & ATOM_S0_CRT1_MASK)
 678                         return connector_status_connected;
 679         } else if (radeon_encoder->atom_device & ATOM_DEVICE_CRT2_SUPPORT) {
 680                 if (bios_0_scratch & ATOM_S0_CRT2_MASK)
 681                         return connector_status_connected;
 682         } else if (radeon_encoder->atom_device & ATOM_DEVICE_CV_SUPPORT) {
 683                 if (bios_0_scratch & (ATOM_S0_CV_MASK|ATOM_S0_CV_MASK_A))
 684                         return connector_status_connected;
 685         } else if (radeon_encoder->atom_device & ATOM_DEVICE_TV1_SUPPORT) {
 686                 if (bios_0_scratch & (ATOM_S0_TV1_COMPOSITE | ATOM_S0_TV1_COMPOSITE_A))
 687                         return connector_status_connected; // CTV
 688                 else if (bios_0_scratch & (ATOM_S0_TV1_SVIDEO | ATOM_S0_TV1_SVIDEO_A))
 689                         return connector_status_connected; // STV
 690         }
 691         return connector_status_disconnected;
 692 }
 693
 694 static const struct drm_encoder_helper_funcs radeon_atom_dac_helper_funcs = {
 695         .dpms = radeon_atom_dac_dpms,
 696         .mode_fixup = radeon_atom_dac_mode_fixup,
 697         .prepare = radeon_atom_dac_prepare,
 698         .mode_set = radeon_atom_dac_mode_set,
 699         .commit = radeon_atom_dac_commit,
 700         .detect = radeon_atom_dac_detect,
 701 };
 702
 703 static const struct drm_encoder_funcs radeon_atom_dac_enc_funcs = {
 704         . destroy = radeon_enc_destroy,
 705 };
 706
 707
 708 static void atombios_tmds1_setup(struct drm_encoder *encoder,
 709                                  struct drm_display_mode *mode)
 710 {
 711         struct drm_device *dev = encoder->dev;
 712         struct drm_radeon_private *dev_priv = dev->dev_private;
 713         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 714         TMDS1_ENCODER_CONTROL_PS_ALLOCATION args;
 715         int index = GetIndexIntoMasterTable(COMMAND, TMDS1EncoderControl);
 716
 717         memset(&args, 0, sizeof(args));
 718         args.ucAction = 1;
 719         if (mode->clock > 165000)
 720                 args.ucMisc = 1;
 721         else
 722                 args.ucMisc = 0;
 723
 724         args.usPixelClock = cpu_to_le16(mode->clock / 10);
 725
 726         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 727 }
 728
 729 static void atombios_tmds2_setup(struct drm_encoder *encoder,
 730                                  struct drm_display_mode *mode)
 731 {
 732         struct drm_device *dev = encoder->dev;
 733         struct drm_radeon_private *dev_priv = dev->dev_private;
 734         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 735         TMDS2_ENCODER_CONTROL_PS_ALLOCATION args;
 736         int index = GetIndexIntoMasterTable(COMMAND, TMDS2EncoderControl);
 737
 738         memset(&args, 0, sizeof(args));
 739         args.ucAction = 1;
 740         if (mode->clock > 165000)
 741                 args.ucMisc = 1;
 742         else
 743                 args.ucMisc = 0;
 744
 745         args.usPixelClock = cpu_to_le16(mode->clock / 10);
 746
 747         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 748 }
 749
 750
 751 static void atombios_ext_tmds_setup(struct drm_encoder *encoder,
 752                                     struct drm_display_mode *mode)
 753 {
 754         struct drm_device *dev = encoder->dev;
 755         struct drm_radeon_private *dev_priv = dev->dev_private;
 756         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 757         ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION args;
 758         int index = GetIndexIntoMasterTable(COMMAND, DVOEncoderControl);
 759
 760         memset(&args, 0, sizeof(args));
 761         args.sXTmdsEncoder.ucEnable = 1;
 762
 763         if (mode->clock > 165000)
 764                 args.sXTmdsEncoder.ucMisc = 1;
 765         else
 766                 args.sXTmdsEncoder.ucMisc = 0;
 767
 768         // TODO 6-bit DAC
 769 //      args.usPixelClock = cpu_to_le16(mode->clock / 10);
 770
 771         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 772 }
 773
 774 static void atombios_dig1_setup(struct drm_encoder *encoder,
 775                                 struct drm_display_mode *mode)
 776 {
 777         struct drm_device *dev = encoder->dev;
 778         struct drm_radeon_private *dev_priv = dev->dev_private;
 779         DIG_ENCODER_CONTROL_PS_ALLOCATION args;
 780         int index = GetIndexIntoMasterTable(COMMAND, DIG1EncoderControl);
 781
 782         args.ucAction = 1;
 783         args.usPixelClock = mode->clock / 10;
 784         args.ucConfig = ATOM_ENCODER_CONFIG_TRANSMITTER1;
 785
 786         // TODO coherent mode
 787 //      if (encoder->coherent_mode)
 788 //              args.ucConfig |= ATOM_TRANSMITTER_CONFIG_COHERENT;
 789
 790         if (mode->clock > 165000) {
 791                 args.ucConfig |= ATOM_ENCODER_CONFIG_LINKA_B;
 792                 args.ucLaneNum = 8;
 793         } else {
 794                 args.ucConfig |= ATOM_ENCODER_CONFIG_LINKA;
 795                 args.ucLaneNum = 4;
 796         }
 797
 798         // TODO Encoder MODE
 799         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 800 }
 801
 802 static void atombios_ddia_setup(struct drm_encoder *encoder,
 803                                 struct drm_display_mode *mode)
 804 {
 805         struct drm_device *dev = encoder->dev;
 806         struct drm_radeon_private *dev_priv = dev->dev_private;
 807         DVO_ENCODER_CONTROL_PS_ALLOCATION args;
 808         int index = GetIndexIntoMasterTable(COMMAND, DVOEncoderControl);
 809
 810         args.sDVOEncoder.ucAction = ATOM_ENABLE;
 811         args.sDVOEncoder.usPixelClock = mode->clock / 10;
 812
 813         if (mode->clock > 165000)
 814                 args.sDVOEncoder.usDevAttr.sDigAttrib.ucAttribute = PANEL_ENCODER_MISC_DUAL;
 815         else
 816                 args.sDVOEncoder.usDevAttr.sDigAttrib.ucAttribute = 0;
 817
 818         atom_execute_table(dev_priv->mode_info.atom_context, index, (uint32_t *)&args);
 819 }
 820
 821 struct drm_encoder *radeon_encoder_atom_dac_add(struct drm_device *dev, int bios_index, int dac_type, int with_tv)
 822 {
 823         struct drm_radeon_private *dev_priv = dev->dev_private;
 824         struct radeon_mode_info *mode_info = &dev_priv->mode_info;
 825         struct radeon_encoder *radeon_encoder = NULL;
 826         struct drm_encoder *encoder;
 827         int type = with_tv ? DRM_MODE_ENCODER_TVDAC : DRM_MODE_ENCODER_DAC;
 828         int found = 0;
 829         int digital_enc_mask = ~(ATOM_DEVICE_DFP1_SUPPORT | ATOM_DEVICE_DFP2_SUPPORT | ATOM_DEVICE_DFP3_SUPPORT |
 830                                 ATOM_DEVICE_LCD1_SUPPORT);
 831         /* we may already have added this encoder */
 832         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 833                 if (encoder->encoder_type != DRM_MODE_ENCODER_DAC ||
 834                     encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
 835                         continue;
 836
 837                 radeon_encoder = to_radeon_encoder(encoder);
 838                 if (radeon_encoder->type.dac == dac_type) {
 839                         found = 1;
 840                         break;
 841                 }
 842         }
 843
 844         if (found) {
 845                 /* upgrade to a TV controlling DAC */
 846                 if (type == DRM_MODE_ENCODER_TVDAC)
 847                         encoder->encoder_type = type;
 848                 radeon_encoder->atom_device |= mode_info->bios_connector[bios_index].devices;
 849                 radeon_encoder->atom_device &= digital_enc_mask;
 850                 return encoder;
 851         }
 852
 853         radeon_encoder = kzalloc(sizeof(struct radeon_encoder), GFP_KERNEL);
 854         if (!radeon_encoder) {
 855                 return NULL;
 856         }
 857
 858         encoder = &radeon_encoder->base;
 859
 860         encoder->possible_crtcs = 0x3;
 861         encoder->possible_clones = 0;
 862         drm_encoder_init(dev, encoder, &radeon_atom_dac_enc_funcs,
 863                          type);
 864
 865         drm_encoder_helper_add(encoder, &radeon_atom_dac_helper_funcs);
 866         radeon_encoder->type.dac = dac_type;
 867         radeon_encoder->atom_device = mode_info->bios_connector[bios_index].devices;
 868
 869         /* mask off any digital encoders */
 870         radeon_encoder->atom_device &= digital_enc_mask;
 871         return encoder;
 872 }
 873
 874 static void radeon_atom_tmds_dpms(struct drm_encoder *encoder, int mode)
 875 {
 876         struct drm_device *dev = encoder->dev;
 877         struct drm_radeon_private *dev_priv = dev->dev_private;
 878         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 879         struct radeon_crtc *radeon_crtc = NULL;
 880         int crtc_id = 0;
 881         int atom_type = -1;
 882         int index = -1;
 883         uint32_t bios_2_scratch, bios_3_scratch;
 884
 885         if (encoder->crtc) {
 886                 radeon_crtc = to_radeon_crtc(encoder->crtc);
 887                 crtc_id = radeon_crtc->crtc_id;
 888         } else if (mode == DRM_MODE_DPMS_ON)
 889                 return;
 890
 891         if (radeon_encoder->atom_device & ATOM_DEVICE_DFP1_SUPPORT)
 892                 atom_type = ATOM_DEVICE_DFP1_INDEX;
 893         if (radeon_encoder->atom_device & ATOM_DEVICE_DFP2_SUPPORT)
 894                 atom_type = ATOM_DEVICE_DFP2_INDEX;
 895         if (radeon_encoder->atom_device & ATOM_DEVICE_DFP3_SUPPORT)
 896                 atom_type = ATOM_DEVICE_DFP3_INDEX;
 897
 898         if (atom_type == -1)
 899                 return;
 900
 901         if (dev_priv->chip_family >= CHIP_R600) {
 902                 bios_2_scratch = RADEON_READ(R600_BIOS_2_SCRATCH);
 903                 bios_3_scratch = RADEON_READ(R600_BIOS_3_SCRATCH);
 904         } else {
 905                 bios_2_scratch = RADEON_READ(RADEON_BIOS_2_SCRATCH);
 906                 bios_3_scratch = RADEON_READ(RADEON_BIOS_3_SCRATCH);
 907         }
 908
 909         switch(atom_type) {
 910         case ATOM_DEVICE_DFP1_INDEX:
 911                 index = GetIndexIntoMasterTable(COMMAND, TMDSAOutputControl);
 912                 bios_2_scratch &= ~ATOM_S3_DFP1_CRTC_ACTIVE;
 913                 bios_3_scratch |= (crtc_id << 19);
 914                 switch(mode) {
 915                 case DRM_MODE_DPMS_ON:
 916                         bios_2_scratch &= ~ATOM_S2_DFP1_DPMS_STATE;
 917                         bios_3_scratch |= ATOM_S3_DFP1_ACTIVE;
 918                         break;
 919                 case DRM_MODE_DPMS_STANDBY:
 920                 case DRM_MODE_DPMS_SUSPEND:
 921                 case DRM_MODE_DPMS_OFF:
 922                         bios_2_scratch |= ATOM_S2_DFP1_DPMS_STATE;
 923                         bios_3_scratch &= ~ATOM_S3_DFP1_ACTIVE;
 924                         break;
 925                 }
 926                 break;
 927         case ATOM_DEVICE_DFP2_INDEX:
 928                 index = GetIndexIntoMasterTable(COMMAND, DVOOutputControl);
 929                 bios_2_scratch &= ~ATOM_S3_DFP2_CRTC_ACTIVE;
 930                 bios_3_scratch |= (crtc_id << 23);
 931                 switch(mode) {
 932                 case DRM_MODE_DPMS_ON:
 933                         bios_2_scratch &= ~ATOM_S2_DFP2_DPMS_STATE;
 934                         bios_3_scratch |= ATOM_S3_DFP2_ACTIVE;
 935                         break;
 936                 case DRM_MODE_DPMS_STANDBY:
 937                 case DRM_MODE_DPMS_SUSPEND:
 938                 case DRM_MODE_DPMS_OFF:
 939                         bios_2_scratch |= ATOM_S2_DFP2_DPMS_STATE;
 940                         bios_3_scratch &= ~ATOM_S3_DFP2_ACTIVE;
 941                         break;
 942                 }
 943                 break;
 944         case ATOM_DEVICE_DFP3_INDEX:
 945                 index = GetIndexIntoMasterTable(COMMAND, LVTMAOutputControl);
 946                 bios_2_scratch &= ~ATOM_S3_DFP3_CRTC_ACTIVE;
 947                 bios_3_scratch |= (crtc_id << 25);
 948                 switch(mode) {
 949                 case DRM_MODE_DPMS_ON:
 950                         bios_2_scratch &= ~ATOM_S2_DFP3_DPMS_STATE;
 951                         bios_3_scratch |= ATOM_S3_DFP3_ACTIVE;
 952                         break;
 953                 case DRM_MODE_DPMS_STANDBY:
 954                 case DRM_MODE_DPMS_SUSPEND:
 955                 case DRM_MODE_DPMS_OFF:
 956                         bios_2_scratch |= ATOM_S2_DFP3_DPMS_STATE;
 957                         bios_3_scratch &= ~ATOM_S3_DFP3_ACTIVE;
 958                         break;
 959                 }
 960                 break;
 961         }
 962
 963         if (index == -1)
 964                 return;
 965
 966         switch(mode) {
 967         case DRM_MODE_DPMS_ON:
 968                 atombios_display_device_control(encoder, index, ATOM_ENABLE);
 969                 break;
 970         case DRM_MODE_DPMS_STANDBY:
 971         case DRM_MODE_DPMS_SUSPEND:
 972         case DRM_MODE_DPMS_OFF:
 973                 atombios_display_device_control(encoder, index, ATOM_DISABLE);
 974                 break;
 975         }
 976
 977         if (dev_priv->chip_family >= CHIP_R600) {
 978                 RADEON_WRITE(R600_BIOS_2_SCRATCH, bios_2_scratch);
 979                 RADEON_WRITE(R600_BIOS_3_SCRATCH, bios_3_scratch);
 980         } else {
 981                 RADEON_WRITE(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
 982                 RADEON_WRITE(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
 983         }
 984 }
 985
 986 static bool radeon_atom_tmds_mode_fixup(struct drm_encoder *encoder,
 987                                   struct drm_display_mode *mode,
 988                                   struct drm_display_mode *adjusted_mode)
 989 {
 990         return true;
 991 }
 992
 993 static void radeon_atom_tmds_mode_set(struct drm_encoder *encoder,
 994                                       struct drm_display_mode *mode,
 995                                       struct drm_display_mode *adjusted_mode)
 996 {
 997         struct drm_device *dev = encoder->dev;
 998         struct drm_radeon_private *dev_priv = dev->dev_private;
 999         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1000         int atom_type;
1001
1002         if (radeon_encoder->atom_device & ATOM_DEVICE_DFP1_SUPPORT)
1003                 atom_type = ATOM_DEVICE_DFP1_INDEX;
1004         if (radeon_encoder->atom_device & ATOM_DEVICE_DFP2_SUPPORT)
1005                 atom_type = ATOM_DEVICE_DFP2_INDEX;
1006         if (radeon_encoder->atom_device & ATOM_DEVICE_DFP3_SUPPORT)
1007                 atom_type = ATOM_DEVICE_DFP3_INDEX;
1008
1009         atombios_scaler_setup(encoder, mode);
1010         atombios_set_crtc_source(encoder, atom_type);
1011
1012         if (atom_type == ATOM_DEVICE_DFP1_INDEX)
1013                 atombios_tmds1_setup(encoder, adjusted_mode);
1014         if (atom_type == ATOM_DEVICE_DFP2_INDEX) {
1015                 if ((dev_priv->chip_family == CHIP_RS600) ||
1016                     (dev_priv->chip_family == CHIP_RS690) ||
1017                     (dev_priv->chip_family == CHIP_RS740))
1018                         atombios_ddia_setup(encoder, adjusted_mode);
1019                 else
1020                         atombios_ext_tmds_setup(encoder, adjusted_mode);
1021         }
1022         if (atom_type == ATOM_DEVICE_DFP3_INDEX)
1023                 atombios_tmds2_setup(encoder, adjusted_mode);
1024         radeon_dfp_disable_dither(encoder, atom_type);
1025
1026
1027 }
1028
1029 static void radeon_atom_tmds_prepare(struct drm_encoder *encoder)
1030 {
1031         radeon_atom_output_lock(encoder, true);
1032         radeon_atom_tmds_dpms(encoder, DRM_MODE_DPMS_OFF);
1033 }
1034
1035 static void radeon_atom_tmds_commit(struct drm_encoder *encoder)
1036 {
1037         radeon_atom_tmds_dpms(encoder, DRM_MODE_DPMS_ON);
1038         radeon_atom_output_lock(encoder, false);
1039 }
1040
1041 static const struct drm_encoder_helper_funcs radeon_atom_tmds_helper_funcs = {
1042         .dpms = radeon_atom_tmds_dpms,
1043         .mode_fixup = radeon_atom_tmds_mode_fixup,
1044         .prepare = radeon_atom_tmds_prepare,
1045         .mode_set = radeon_atom_tmds_mode_set,
1046         .commit = radeon_atom_tmds_commit,
1047         /* no detect for TMDS */
1048 };
1049
1050 static const struct drm_encoder_funcs radeon_atom_tmds_enc_funcs = {
1051         . destroy = radeon_enc_destroy,
1052 };
1053
1054 struct drm_encoder *radeon_encoder_atom_tmds_add(struct drm_device *dev, int bios_index, int tmds_type)
1055 {
1056         struct drm_radeon_private *dev_priv = dev->dev_private;
1057         struct radeon_mode_info *mode_info = &dev_priv->mode_info;
1058         struct radeon_encoder *radeon_encoder = NULL;
1059         struct drm_encoder *encoder;
1060         int analog_enc_mask = ~(ATOM_DEVICE_CRT1_SUPPORT | ATOM_DEVICE_CRT2_SUPPORT);
1061
1062                 radeon_encoder = kzalloc(sizeof(struct radeon_encoder), GFP_KERNEL);
1063         if (!radeon_encoder) {
1064                 return NULL;
1065         }
1066
1067         encoder = &radeon_encoder->base;
1068
1069         encoder->possible_crtcs = 0x3;
1070         encoder->possible_clones = 0;
1071         drm_encoder_init(dev, encoder, &radeon_atom_tmds_enc_funcs,
1072                          DRM_MODE_ENCODER_TMDS);
1073
1074         drm_encoder_helper_add(encoder, &radeon_atom_tmds_helper_funcs);
1075
1076         radeon_encoder->atom_device = mode_info->bios_connector[bios_index].devices;
1077
1078         /* mask off any analog encoders */
1079         radeon_encoder->atom_device &= analog_enc_mask;
1080         return encoder;
1081 }