drivers/gpu/drm/radeon/radeon_atombios.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 <drm/drmP.h>
  27 #include <drm/radeon_drm.h>
  28 #include "radeon.h"
  29
  30 #include "atom.h"
  31 #include "atom-bits.h"
  32
  33 /* from radeon_encoder.c */
  34 extern uint32_t
  35 radeon_get_encoder_enum(struct drm_device *dev, uint32_t supported_device,
  36                         uint8_t dac);
  37 extern void radeon_link_encoder_connector(struct drm_device *dev);
  38 extern void
  39 radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_enum,
  40                         uint32_t supported_device, u16 caps);
  41
  42 /* from radeon_connector.c */
  43 extern void
  44 radeon_add_atom_connector(struct drm_device *dev,
  45                           uint32_t connector_id,
  46                           uint32_t supported_device,
  47                           int connector_type,
  48                           struct radeon_i2c_bus_rec *i2c_bus,
  49                           uint32_t igp_lane_info,
  50                           uint16_t connector_object_id,
  51                           struct radeon_hpd *hpd,
  52                           struct radeon_router *router);
  53
  54 /* from radeon_legacy_encoder.c */
  55 extern void
  56 radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_enum,
  57                           uint32_t supported_device);
  58
  59 /* local */
  60 static int radeon_atom_get_max_vddc(struct radeon_device *rdev, u8 voltage_type,
  61                                     u16 voltage_id, u16 *voltage);
  62
  63 union atom_supported_devices {
  64         struct _ATOM_SUPPORTED_DEVICES_INFO info;
  65         struct _ATOM_SUPPORTED_DEVICES_INFO_2 info_2;
  66         struct _ATOM_SUPPORTED_DEVICES_INFO_2d1 info_2d1;
  67 };
  68
  69 static void radeon_lookup_i2c_gpio_quirks(struct radeon_device *rdev,
  70                                           ATOM_GPIO_I2C_ASSIGMENT *gpio,
  71                                           u8 index)
  72 {
  73         /* r4xx mask is technically not used by the hw, so patch in the legacy mask bits */
  74         if ((rdev->family == CHIP_R420) ||
  75             (rdev->family == CHIP_R423) ||
  76             (rdev->family == CHIP_RV410)) {
  77                 if ((le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x0018) ||
  78                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x0019) ||
  79                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x001a)) {
  80                         gpio->ucClkMaskShift = 0x19;
  81                         gpio->ucDataMaskShift = 0x18;
  82                 }
  83         }
  84
  85         /* some evergreen boards have bad data for this entry */
  86         if (ASIC_IS_DCE4(rdev)) {
  87                 if ((index == 7) &&
  88                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1936) &&
  89                     (gpio->sucI2cId.ucAccess == 0)) {
  90                         gpio->sucI2cId.ucAccess = 0x97;
  91                         gpio->ucDataMaskShift = 8;
  92                         gpio->ucDataEnShift = 8;
  93                         gpio->ucDataY_Shift = 8;
  94                         gpio->ucDataA_Shift = 8;
  95                 }
  96         }
  97
  98         /* some DCE3 boards have bad data for this entry */
  99         if (ASIC_IS_DCE3(rdev)) {
 100                 if ((index == 4) &&
 101                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1fda) &&
 102                     (gpio->sucI2cId.ucAccess == 0x94))
 103                         gpio->sucI2cId.ucAccess = 0x14;
 104         }
 105 }
 106
 107 static struct radeon_i2c_bus_rec radeon_get_bus_rec_for_i2c_gpio(ATOM_GPIO_I2C_ASSIGMENT *gpio)
 108 {
 109         struct radeon_i2c_bus_rec i2c;
 110
 111         memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
 112
 113         i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
 114         i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
 115         i2c.en_clk_reg = le16_to_cpu(gpio->usClkEnRegisterIndex) * 4;
 116         i2c.en_data_reg = le16_to_cpu(gpio->usDataEnRegisterIndex) * 4;
 117         i2c.y_clk_reg = le16_to_cpu(gpio->usClkY_RegisterIndex) * 4;
 118         i2c.y_data_reg = le16_to_cpu(gpio->usDataY_RegisterIndex) * 4;
 119         i2c.a_clk_reg = le16_to_cpu(gpio->usClkA_RegisterIndex) * 4;
 120         i2c.a_data_reg = le16_to_cpu(gpio->usDataA_RegisterIndex) * 4;
 121         i2c.mask_clk_mask = (1 << gpio->ucClkMaskShift);
 122         i2c.mask_data_mask = (1 << gpio->ucDataMaskShift);
 123         i2c.en_clk_mask = (1 << gpio->ucClkEnShift);
 124         i2c.en_data_mask = (1 << gpio->ucDataEnShift);
 125         i2c.y_clk_mask = (1 << gpio->ucClkY_Shift);
 126         i2c.y_data_mask = (1 << gpio->ucDataY_Shift);
 127         i2c.a_clk_mask = (1 << gpio->ucClkA_Shift);
 128         i2c.a_data_mask = (1 << gpio->ucDataA_Shift);
 129
 130         if (gpio->sucI2cId.sbfAccess.bfHW_Capable)
 131                 i2c.hw_capable = true;
 132         else
 133                 i2c.hw_capable = false;
 134
 135         if (gpio->sucI2cId.ucAccess == 0xa0)
 136                 i2c.mm_i2c = true;
 137         else
 138                 i2c.mm_i2c = false;
 139
 140         i2c.i2c_id = gpio->sucI2cId.ucAccess;
 141
 142         if (i2c.mask_clk_reg)
 143                 i2c.valid = true;
 144         else
 145                 i2c.valid = false;
 146
 147         return i2c;
 148 }
 149
 150 static struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_device *rdev,
 151                                                                uint8_t id)
 152 {
 153         struct atom_context *ctx = rdev->mode_info.atom_context;
 154         ATOM_GPIO_I2C_ASSIGMENT *gpio;
 155         struct radeon_i2c_bus_rec i2c;
 156         int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
 157         struct _ATOM_GPIO_I2C_INFO *i2c_info;
 158         uint16_t data_offset, size;
 159         int i, num_indices;
 160
 161         memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
 162         i2c.valid = false;
 163
 164         if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
 165                 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
 166
 167                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
 168                         sizeof(ATOM_GPIO_I2C_ASSIGMENT);
 169
 170                 for (i = 0; i < num_indices; i++) {
 171                         gpio = &i2c_info->asGPIO_Info[i];
 172
 173                         radeon_lookup_i2c_gpio_quirks(rdev, gpio, i);
 174
 175                         if (gpio->sucI2cId.ucAccess == id) {
 176                                 i2c = radeon_get_bus_rec_for_i2c_gpio(gpio);
 177                                 break;
 178                         }
 179                 }
 180         }
 181
 182         return i2c;
 183 }
 184
 185 void radeon_atombios_i2c_init(struct radeon_device *rdev)
 186 {
 187         struct atom_context *ctx = rdev->mode_info.atom_context;
 188         ATOM_GPIO_I2C_ASSIGMENT *gpio;
 189         struct radeon_i2c_bus_rec i2c;
 190         int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
 191         struct _ATOM_GPIO_I2C_INFO *i2c_info;
 192         uint16_t data_offset, size;
 193         int i, num_indices;
 194         char stmp[32];
 195
 196         if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
 197                 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
 198
 199                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
 200                         sizeof(ATOM_GPIO_I2C_ASSIGMENT);
 201
 202                 for (i = 0; i < num_indices; i++) {
 203                         gpio = &i2c_info->asGPIO_Info[i];
 204
 205                         radeon_lookup_i2c_gpio_quirks(rdev, gpio, i);
 206
 207                         i2c = radeon_get_bus_rec_for_i2c_gpio(gpio);
 208
 209                         if (i2c.valid) {
 210                                 sprintf(stmp, "0x%x", i2c.i2c_id);
 211                                 rdev->i2c_bus[i] = radeon_i2c_create(rdev->ddev, &i2c, stmp);
 212                         }
 213                 }
 214         }
 215 }
 216
 217 static struct radeon_gpio_rec radeon_lookup_gpio(struct radeon_device *rdev,
 218                                                         u8 id)
 219 {
 220         struct atom_context *ctx = rdev->mode_info.atom_context;
 221         struct radeon_gpio_rec gpio;
 222         int index = GetIndexIntoMasterTable(DATA, GPIO_Pin_LUT);
 223         struct _ATOM_GPIO_PIN_LUT *gpio_info;
 224         ATOM_GPIO_PIN_ASSIGNMENT *pin;
 225         u16 data_offset, size;
 226         int i, num_indices;
 227
 228         memset(&gpio, 0, sizeof(struct radeon_gpio_rec));
 229         gpio.valid = false;
 230
 231         if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
 232                 gpio_info = (struct _ATOM_GPIO_PIN_LUT *)(ctx->bios + data_offset);
 233
 234                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
 235                         sizeof(ATOM_GPIO_PIN_ASSIGNMENT);
 236
 237                 for (i = 0; i < num_indices; i++) {
 238                         pin = &gpio_info->asGPIO_Pin[i];
 239                         if (id == pin->ucGPIO_ID) {
 240                                 gpio.id = pin->ucGPIO_ID;
 241                                 gpio.reg = le16_to_cpu(pin->usGpioPin_AIndex) * 4;
 242                                 gpio.mask = (1 << pin->ucGpioPinBitShift);
 243                                 gpio.valid = true;
 244                                 break;
 245                         }
 246                 }
 247         }
 248
 249         return gpio;
 250 }
 251
 252 static struct radeon_hpd radeon_atom_get_hpd_info_from_gpio(struct radeon_device *rdev,
 253                                                             struct radeon_gpio_rec *gpio)
 254 {
 255         struct radeon_hpd hpd;
 256         u32 reg;
 257
 258         memset(&hpd, 0, sizeof(struct radeon_hpd));
 259
 260         if (ASIC_IS_DCE6(rdev))
 261                 reg = SI_DC_GPIO_HPD_A;
 262         else if (ASIC_IS_DCE4(rdev))
 263                 reg = EVERGREEN_DC_GPIO_HPD_A;
 264         else
 265                 reg = AVIVO_DC_GPIO_HPD_A;
 266
 267         hpd.gpio = *gpio;
 268         if (gpio->reg == reg) {
 269                 switch(gpio->mask) {
 270                 case (1 << 0):
 271                         hpd.hpd = RADEON_HPD_1;
 272                         break;
 273                 case (1 << 8):
 274                         hpd.hpd = RADEON_HPD_2;
 275                         break;
 276                 case (1 << 16):
 277                         hpd.hpd = RADEON_HPD_3;
 278                         break;
 279                 case (1 << 24):
 280                         hpd.hpd = RADEON_HPD_4;
 281                         break;
 282                 case (1 << 26):
 283                         hpd.hpd = RADEON_HPD_5;
 284                         break;
 285                 case (1 << 28):
 286                         hpd.hpd = RADEON_HPD_6;
 287                         break;
 288                 default:
 289                         hpd.hpd = RADEON_HPD_NONE;
 290                         break;
 291                 }
 292         } else
 293                 hpd.hpd = RADEON_HPD_NONE;
 294         return hpd;
 295 }
 296
 297 static bool radeon_atom_apply_quirks(struct drm_device *dev,
 298                                      uint32_t supported_device,
 299                                      int *connector_type,
 300                                      struct radeon_i2c_bus_rec *i2c_bus,
 301                                      uint16_t *line_mux,
 302                                      struct radeon_hpd *hpd)
 303 {
 304
 305         /* Asus M2A-VM HDMI board lists the DVI port as HDMI */
 306         if ((dev->pdev->device == 0x791e) &&
 307             (dev->pdev->subsystem_vendor == 0x1043) &&
 308             (dev->pdev->subsystem_device == 0x826d)) {
 309                 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
 310                     (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
 311                         *connector_type = DRM_MODE_CONNECTOR_DVID;
 312         }
 313
 314         /* Asrock RS600 board lists the DVI port as HDMI */
 315         if ((dev->pdev->device == 0x7941) &&
 316             (dev->pdev->subsystem_vendor == 0x1849) &&
 317             (dev->pdev->subsystem_device == 0x7941)) {
 318                 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
 319                     (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
 320                         *connector_type = DRM_MODE_CONNECTOR_DVID;
 321         }
 322
 323         /* MSI K9A2GM V2/V3 board has no HDMI or DVI */
 324         if ((dev->pdev->device == 0x796e) &&
 325             (dev->pdev->subsystem_vendor == 0x1462) &&
 326             (dev->pdev->subsystem_device == 0x7302)) {
 327                 if ((supported_device == ATOM_DEVICE_DFP2_SUPPORT) ||
 328                     (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
 329                         return false;
 330         }
 331
 332         /* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */
 333         if ((dev->pdev->device == 0x7941) &&
 334             (dev->pdev->subsystem_vendor == 0x147b) &&
 335             (dev->pdev->subsystem_device == 0x2412)) {
 336                 if (*connector_type == DRM_MODE_CONNECTOR_DVII)
 337                         return false;
 338         }
 339
 340         /* Falcon NW laptop lists vga ddc line for LVDS */
 341         if ((dev->pdev->device == 0x5653) &&
 342             (dev->pdev->subsystem_vendor == 0x1462) &&
 343             (dev->pdev->subsystem_device == 0x0291)) {
 344                 if (*connector_type == DRM_MODE_CONNECTOR_LVDS) {
 345                         i2c_bus->valid = false;
 346                         *line_mux = 53;
 347                 }
 348         }
 349
 350         /* HIS X1300 is DVI+VGA, not DVI+DVI */
 351         if ((dev->pdev->device == 0x7146) &&
 352             (dev->pdev->subsystem_vendor == 0x17af) &&
 353             (dev->pdev->subsystem_device == 0x2058)) {
 354                 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
 355                         return false;
 356         }
 357
 358         /* Gigabyte X1300 is DVI+VGA, not DVI+DVI */
 359         if ((dev->pdev->device == 0x7142) &&
 360             (dev->pdev->subsystem_vendor == 0x1458) &&
 361             (dev->pdev->subsystem_device == 0x2134)) {
 362                 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
 363                         return false;
 364         }
 365
 366
 367         /* Funky macbooks */
 368         if ((dev->pdev->device == 0x71C5) &&
 369             (dev->pdev->subsystem_vendor == 0x106b) &&
 370             (dev->pdev->subsystem_device == 0x0080)) {
 371                 if ((supported_device == ATOM_DEVICE_CRT1_SUPPORT) ||
 372                     (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
 373                         return false;
 374                 if (supported_device == ATOM_DEVICE_CRT2_SUPPORT)
 375                         *line_mux = 0x90;
 376         }
 377
 378         /* mac rv630, rv730, others */
 379         if ((supported_device == ATOM_DEVICE_TV1_SUPPORT) &&
 380             (*connector_type == DRM_MODE_CONNECTOR_DVII)) {
 381                 *connector_type = DRM_MODE_CONNECTOR_9PinDIN;
 382                 *line_mux = CONNECTOR_7PIN_DIN_ENUM_ID1;
 383         }
 384
 385         /* ASUS HD 3600 XT board lists the DVI port as HDMI */
 386         if ((dev->pdev->device == 0x9598) &&
 387             (dev->pdev->subsystem_vendor == 0x1043) &&
 388             (dev->pdev->subsystem_device == 0x01da)) {
 389                 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 390                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 391                 }
 392         }
 393
 394         /* ASUS HD 3600 board lists the DVI port as HDMI */
 395         if ((dev->pdev->device == 0x9598) &&
 396             (dev->pdev->subsystem_vendor == 0x1043) &&
 397             (dev->pdev->subsystem_device == 0x01e4)) {
 398                 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 399                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 400                 }
 401         }
 402
 403         /* ASUS HD 3450 board lists the DVI port as HDMI */
 404         if ((dev->pdev->device == 0x95C5) &&
 405             (dev->pdev->subsystem_vendor == 0x1043) &&
 406             (dev->pdev->subsystem_device == 0x01e2)) {
 407                 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 408                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 409                 }
 410         }
 411
 412         /* some BIOSes seem to report DAC on HDMI - usually this is a board with
 413          * HDMI + VGA reporting as HDMI
 414          */
 415         if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 416                 if (supported_device & (ATOM_DEVICE_CRT_SUPPORT)) {
 417                         *connector_type = DRM_MODE_CONNECTOR_VGA;
 418                         *line_mux = 0;
 419                 }
 420         }
 421
 422         /* Acer laptop (Acer TravelMate 5730/5730G) has an HDMI port
 423          * on the laptop and a DVI port on the docking station and
 424          * both share the same encoder, hpd pin, and ddc line.
 425          * So while the bios table is technically correct,
 426          * we drop the DVI port here since xrandr has no concept of
 427          * encoders and will try and drive both connectors
 428          * with different crtcs which isn't possible on the hardware
 429          * side and leaves no crtcs for LVDS or VGA.
 430          */
 431         if (((dev->pdev->device == 0x95c4) || (dev->pdev->device == 0x9591)) &&
 432             (dev->pdev->subsystem_vendor == 0x1025) &&
 433             (dev->pdev->subsystem_device == 0x013c)) {
 434                 if ((*connector_type == DRM_MODE_CONNECTOR_DVII) &&
 435                     (supported_device == ATOM_DEVICE_DFP1_SUPPORT)) {
 436                         /* actually it's a DVI-D port not DVI-I */
 437                         *connector_type = DRM_MODE_CONNECTOR_DVID;
 438                         return false;
 439                 }
 440         }
 441
 442         /* XFX Pine Group device rv730 reports no VGA DDC lines
 443          * even though they are wired up to record 0x93
 444          */
 445         if ((dev->pdev->device == 0x9498) &&
 446             (dev->pdev->subsystem_vendor == 0x1682) &&
 447             (dev->pdev->subsystem_device == 0x2452) &&
 448             (i2c_bus->valid == false) &&
 449             !(supported_device & (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT))) {
 450                 struct radeon_device *rdev = dev->dev_private;
 451                 *i2c_bus = radeon_lookup_i2c_gpio(rdev, 0x93);
 452         }
 453
 454         /* Fujitsu D3003-S2 board lists DVI-I as DVI-D and VGA */
 455         if (((dev->pdev->device == 0x9802) || (dev->pdev->device == 0x9806)) &&
 456             (dev->pdev->subsystem_vendor == 0x1734) &&
 457             (dev->pdev->subsystem_device == 0x11bd)) {
 458                 if (*connector_type == DRM_MODE_CONNECTOR_VGA) {
 459                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 460                         *line_mux = 0x3103;
 461                 } else if (*connector_type == DRM_MODE_CONNECTOR_DVID) {
 462                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 463                 }
 464         }
 465
 466
 467         return true;
 468 }
 469
 470 const int supported_devices_connector_convert[] = {
 471         DRM_MODE_CONNECTOR_Unknown,
 472         DRM_MODE_CONNECTOR_VGA,
 473         DRM_MODE_CONNECTOR_DVII,
 474         DRM_MODE_CONNECTOR_DVID,
 475         DRM_MODE_CONNECTOR_DVIA,
 476         DRM_MODE_CONNECTOR_SVIDEO,
 477         DRM_MODE_CONNECTOR_Composite,
 478         DRM_MODE_CONNECTOR_LVDS,
 479         DRM_MODE_CONNECTOR_Unknown,
 480         DRM_MODE_CONNECTOR_Unknown,
 481         DRM_MODE_CONNECTOR_HDMIA,
 482         DRM_MODE_CONNECTOR_HDMIB,
 483         DRM_MODE_CONNECTOR_Unknown,
 484         DRM_MODE_CONNECTOR_Unknown,
 485         DRM_MODE_CONNECTOR_9PinDIN,
 486         DRM_MODE_CONNECTOR_DisplayPort
 487 };
 488
 489 const uint16_t supported_devices_connector_object_id_convert[] = {
 490         CONNECTOR_OBJECT_ID_NONE,
 491         CONNECTOR_OBJECT_ID_VGA,
 492         CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I, /* not all boards support DL */
 493         CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D, /* not all boards support DL */
 494         CONNECTOR_OBJECT_ID_VGA, /* technically DVI-A */
 495         CONNECTOR_OBJECT_ID_COMPOSITE,
 496         CONNECTOR_OBJECT_ID_SVIDEO,
 497         CONNECTOR_OBJECT_ID_LVDS,
 498         CONNECTOR_OBJECT_ID_9PIN_DIN,
 499         CONNECTOR_OBJECT_ID_9PIN_DIN,
 500         CONNECTOR_OBJECT_ID_DISPLAYPORT,
 501         CONNECTOR_OBJECT_ID_HDMI_TYPE_A,
 502         CONNECTOR_OBJECT_ID_HDMI_TYPE_B,
 503         CONNECTOR_OBJECT_ID_SVIDEO
 504 };
 505
 506 const int object_connector_convert[] = {
 507         DRM_MODE_CONNECTOR_Unknown,
 508         DRM_MODE_CONNECTOR_DVII,
 509         DRM_MODE_CONNECTOR_DVII,
 510         DRM_MODE_CONNECTOR_DVID,
 511         DRM_MODE_CONNECTOR_DVID,
 512         DRM_MODE_CONNECTOR_VGA,
 513         DRM_MODE_CONNECTOR_Composite,
 514         DRM_MODE_CONNECTOR_SVIDEO,
 515         DRM_MODE_CONNECTOR_Unknown,
 516         DRM_MODE_CONNECTOR_Unknown,
 517         DRM_MODE_CONNECTOR_9PinDIN,
 518         DRM_MODE_CONNECTOR_Unknown,
 519         DRM_MODE_CONNECTOR_HDMIA,
 520         DRM_MODE_CONNECTOR_HDMIB,
 521         DRM_MODE_CONNECTOR_LVDS,
 522         DRM_MODE_CONNECTOR_9PinDIN,
 523         DRM_MODE_CONNECTOR_Unknown,
 524         DRM_MODE_CONNECTOR_Unknown,
 525         DRM_MODE_CONNECTOR_Unknown,
 526         DRM_MODE_CONNECTOR_DisplayPort,
 527         DRM_MODE_CONNECTOR_eDP,
 528         DRM_MODE_CONNECTOR_Unknown
 529 };
 530
 531 bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
 532 {
 533         struct radeon_device *rdev = dev->dev_private;
 534         struct radeon_mode_info *mode_info = &rdev->mode_info;
 535         struct atom_context *ctx = mode_info->atom_context;
 536         int index = GetIndexIntoMasterTable(DATA, Object_Header);
 537         u16 size, data_offset;
 538         u8 frev, crev;
 539         ATOM_CONNECTOR_OBJECT_TABLE *con_obj;
 540         ATOM_ENCODER_OBJECT_TABLE *enc_obj;
 541         ATOM_OBJECT_TABLE *router_obj;
 542         ATOM_DISPLAY_OBJECT_PATH_TABLE *path_obj;
 543         ATOM_OBJECT_HEADER *obj_header;
 544         int i, j, k, path_size, device_support;
 545         int connector_type;
 546         u16 igp_lane_info, conn_id, connector_object_id;
 547         struct radeon_i2c_bus_rec ddc_bus;
 548         struct radeon_router router;
 549         struct radeon_gpio_rec gpio;
 550         struct radeon_hpd hpd;
 551
 552         if (!atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset))
 553                 return false;
 554
 555         if (crev < 2)
 556                 return false;
 557
 558         obj_header = (ATOM_OBJECT_HEADER *) (ctx->bios + data_offset);
 559         path_obj = (ATOM_DISPLAY_OBJECT_PATH_TABLE *)
 560             (ctx->bios + data_offset +
 561              le16_to_cpu(obj_header->usDisplayPathTableOffset));
 562         con_obj = (ATOM_CONNECTOR_OBJECT_TABLE *)
 563             (ctx->bios + data_offset +
 564              le16_to_cpu(obj_header->usConnectorObjectTableOffset));
 565         enc_obj = (ATOM_ENCODER_OBJECT_TABLE *)
 566             (ctx->bios + data_offset +
 567              le16_to_cpu(obj_header->usEncoderObjectTableOffset));
 568         router_obj = (ATOM_OBJECT_TABLE *)
 569                 (ctx->bios + data_offset +
 570                  le16_to_cpu(obj_header->usRouterObjectTableOffset));
 571         device_support = le16_to_cpu(obj_header->usDeviceSupport);
 572
 573         path_size = 0;
 574         for (i = 0; i < path_obj->ucNumOfDispPath; i++) {
 575                 uint8_t *addr = (uint8_t *) path_obj->asDispPath;
 576                 ATOM_DISPLAY_OBJECT_PATH *path;
 577                 addr += path_size;
 578                 path = (ATOM_DISPLAY_OBJECT_PATH *) addr;
 579                 path_size += le16_to_cpu(path->usSize);
 580
 581                 if (device_support & le16_to_cpu(path->usDeviceTag)) {
 582                         uint8_t con_obj_id, con_obj_num, con_obj_type;
 583
 584                         con_obj_id =
 585                             (le16_to_cpu(path->usConnObjectId) & OBJECT_ID_MASK)
 586                             >> OBJECT_ID_SHIFT;
 587                         con_obj_num =
 588                             (le16_to_cpu(path->usConnObjectId) & ENUM_ID_MASK)
 589                             >> ENUM_ID_SHIFT;
 590                         con_obj_type =
 591                             (le16_to_cpu(path->usConnObjectId) &
 592                              OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
 593
 594                         /* TODO CV support */
 595                         if (le16_to_cpu(path->usDeviceTag) ==
 596                                 ATOM_DEVICE_CV_SUPPORT)
 597                                 continue;
 598
 599                         /* IGP chips */
 600                         if ((rdev->flags & RADEON_IS_IGP) &&
 601                             (con_obj_id ==
 602                              CONNECTOR_OBJECT_ID_PCIE_CONNECTOR)) {
 603                                 uint16_t igp_offset = 0;
 604                                 ATOM_INTEGRATED_SYSTEM_INFO_V2 *igp_obj;
 605
 606                                 index =
 607                                     GetIndexIntoMasterTable(DATA,
 608                                                             IntegratedSystemInfo);
 609
 610                                 if (atom_parse_data_header(ctx, index, &size, &frev,
 611                                                            &crev, &igp_offset)) {
 612
 613                                         if (crev >= 2) {
 614                                                 igp_obj =
 615                                                         (ATOM_INTEGRATED_SYSTEM_INFO_V2
 616                                                          *) (ctx->bios + igp_offset);
 617
 618                                                 if (igp_obj) {
 619                                                         uint32_t slot_config, ct;
 620
 621                                                         if (con_obj_num == 1)
 622                                                                 slot_config =
 623                                                                         igp_obj->
 624                                                                         ulDDISlot1Config;
 625                                                         else
 626                                                                 slot_config =
 627                                                                         igp_obj->
 628                                                                         ulDDISlot2Config;
 629
 630                                                         ct = (slot_config >> 16) & 0xff;
 631                                                         connector_type =
 632                                                                 object_connector_convert
 633                                                                 [ct];
 634                                                         connector_object_id = ct;
 635                                                         igp_lane_info =
 636                                                                 slot_config & 0xffff;
 637                                                 } else
 638                                                         continue;
 639                                         } else
 640                                                 continue;
 641                                 } else {
 642                                         igp_lane_info = 0;
 643                                         connector_type =
 644                                                 object_connector_convert[con_obj_id];
 645                                         connector_object_id = con_obj_id;
 646                                 }
 647                         } else {
 648                                 igp_lane_info = 0;
 649                                 connector_type =
 650                                     object_connector_convert[con_obj_id];
 651                                 connector_object_id = con_obj_id;
 652                         }
 653
 654                         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
 655                                 continue;
 656
 657                         router.ddc_valid = false;
 658                         router.cd_valid = false;
 659                         for (j = 0; j < ((le16_to_cpu(path->usSize) - 8) / 2); j++) {
 660                                 uint8_t grph_obj_id, grph_obj_num, grph_obj_type;
 661
 662                                 grph_obj_id =
 663                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
 664                                      OBJECT_ID_MASK) >> OBJECT_ID_SHIFT;
 665                                 grph_obj_num =
 666                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
 667                                      ENUM_ID_MASK) >> ENUM_ID_SHIFT;
 668                                 grph_obj_type =
 669                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
 670                                      OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
 671
 672                                 if (grph_obj_type == GRAPH_OBJECT_TYPE_ENCODER) {
 673                                         for (k = 0; k < enc_obj->ucNumberOfObjects; k++) {
 674                                                 u16 encoder_obj = le16_to_cpu(enc_obj->asObjects[k].usObjectID);
 675                                                 if (le16_to_cpu(path->usGraphicObjIds[j]) == encoder_obj) {
 676                                                         ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
 677                                                                 (ctx->bios + data_offset +
 678                                                                  le16_to_cpu(enc_obj->asObjects[k].usRecordOffset));
 679                                                         ATOM_ENCODER_CAP_RECORD *cap_record;
 680                                                         u16 caps = 0;
 681
 682                                                         while (record->ucRecordSize > 0 &&
 683                                                                record->ucRecordType > 0 &&
 684                                                                record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
 685                                                                 switch (record->ucRecordType) {
 686                                                                 case ATOM_ENCODER_CAP_RECORD_TYPE:
 687                                                                         cap_record =(ATOM_ENCODER_CAP_RECORD *)
 688                                                                                 record;
 689                                                                         caps = le16_to_cpu(cap_record->usEncoderCap);
 690                                                                         break;
 691                                                                 }
 692                                                                 record = (ATOM_COMMON_RECORD_HEADER *)
 693                                                                         ((char *)record + record->ucRecordSize);
 694                                                         }
 695                                                         radeon_add_atom_encoder(dev,
 696                                                                                 encoder_obj,
 697                                                                                 le16_to_cpu
 698                                                                                 (path->
 699                                                                                  usDeviceTag),
 700                                                                                 caps);
 701                                                 }
 702                                         }
 703                                 } else if (grph_obj_type == GRAPH_OBJECT_TYPE_ROUTER) {
 704                                         for (k = 0; k < router_obj->ucNumberOfObjects; k++) {
 705                                                 u16 router_obj_id = le16_to_cpu(router_obj->asObjects[k].usObjectID);
 706                                                 if (le16_to_cpu(path->usGraphicObjIds[j]) == router_obj_id) {
 707                                                         ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
 708                                                                 (ctx->bios + data_offset +
 709                                                                  le16_to_cpu(router_obj->asObjects[k].usRecordOffset));
 710                                                         ATOM_I2C_RECORD *i2c_record;
 711                                                         ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
 712                                                         ATOM_ROUTER_DDC_PATH_SELECT_RECORD *ddc_path;
 713                                                         ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *cd_path;
 714                                                         ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *router_src_dst_table =
 715                                                                 (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *)
 716                                                                 (ctx->bios + data_offset +
 717                                                                  le16_to_cpu(router_obj->asObjects[k].usSrcDstTableOffset));
 718                                                         int enum_id;
 719
 720                                                         router.router_id = router_obj_id;
 721                                                         for (enum_id = 0; enum_id < router_src_dst_table->ucNumberOfDst;
 722                                                              enum_id++) {
 723                                                                 if (le16_to_cpu(path->usConnObjectId) ==
 724                                                                     le16_to_cpu(router_src_dst_table->usDstObjectID[enum_id]))
 725                                                                         break;
 726                                                         }
 727
 728                                                         while (record->ucRecordSize > 0 &&
 729                                                                record->ucRecordType > 0 &&
 730                                                                record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
 731                                                                 switch (record->ucRecordType) {
 732                                                                 case ATOM_I2C_RECORD_TYPE:
 733                                                                         i2c_record =
 734                                                                                 (ATOM_I2C_RECORD *)
 735                                                                                 record;
 736                                                                         i2c_config =
 737                                                                                 (ATOM_I2C_ID_CONFIG_ACCESS *)
 738                                                                                 &i2c_record->sucI2cId;
 739                                                                         router.i2c_info =
 740                                                                                 radeon_lookup_i2c_gpio(rdev,
 741                                                                                                        i2c_config->
 742                                                                                                        ucAccess);
 743                                                                         router.i2c_addr = i2c_record->ucI2CAddr >> 1;
 744                                                                         break;
 745                                                                 case ATOM_ROUTER_DDC_PATH_SELECT_RECORD_TYPE:
 746                                                                         ddc_path = (ATOM_ROUTER_DDC_PATH_SELECT_RECORD *)
 747                                                                                 record;
 748                                                                         router.ddc_valid = true;
 749                                                                         router.ddc_mux_type = ddc_path->ucMuxType;
 750                                                                         router.ddc_mux_control_pin = ddc_path->ucMuxControlPin;
 751                                                                         router.ddc_mux_state = ddc_path->ucMuxState[enum_id];
 752                                                                         break;
 753                                                                 case ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD_TYPE:
 754                                                                         cd_path = (ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *)
 755                                                                                 record;
 756                                                                         router.cd_valid = true;
 757                                                                         router.cd_mux_type = cd_path->ucMuxType;
 758                                                                         router.cd_mux_control_pin = cd_path->ucMuxControlPin;
 759                                                                         router.cd_mux_state = cd_path->ucMuxState[enum_id];
 760                                                                         break;
 761                                                                 }
 762                                                                 record = (ATOM_COMMON_RECORD_HEADER *)
 763                                                                         ((char *)record + record->ucRecordSize);
 764                                                         }
 765                                                 }
 766                                         }
 767                                 }
 768                         }
 769
 770                         /* look up gpio for ddc, hpd */
 771                         ddc_bus.valid = false;
 772                         hpd.hpd = RADEON_HPD_NONE;
 773                         if ((le16_to_cpu(path->usDeviceTag) &
 774                              (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) == 0) {
 775                                 for (j = 0; j < con_obj->ucNumberOfObjects; j++) {
 776                                         if (le16_to_cpu(path->usConnObjectId) ==
 777                                             le16_to_cpu(con_obj->asObjects[j].
 778                                                         usObjectID)) {
 779                                                 ATOM_COMMON_RECORD_HEADER
 780                                                     *record =
 781                                                     (ATOM_COMMON_RECORD_HEADER
 782                                                      *)
 783                                                     (ctx->bios + data_offset +
 784                                                      le16_to_cpu(con_obj->
 785                                                                  asObjects[j].
 786                                                                  usRecordOffset));
 787                                                 ATOM_I2C_RECORD *i2c_record;
 788                                                 ATOM_HPD_INT_RECORD *hpd_record;
 789                                                 ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
 790
 791                                                 while (record->ucRecordSize > 0 &&
 792                                                        record->ucRecordType > 0 &&
 793                                                        record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
 794                                                         switch (record->ucRecordType) {
 795                                                         case ATOM_I2C_RECORD_TYPE:
 796                                                                 i2c_record =
 797                                                                     (ATOM_I2C_RECORD *)
 798                                                                         record;
 799                                                                 i2c_config =
 800                                                                         (ATOM_I2C_ID_CONFIG_ACCESS *)
 801                                                                         &i2c_record->sucI2cId;
 802                                                                 ddc_bus = radeon_lookup_i2c_gpio(rdev,
 803                                                                                                  i2c_config->
 804                                                                                                  ucAccess);
 805                                                                 break;
 806                                                         case ATOM_HPD_INT_RECORD_TYPE:
 807                                                                 hpd_record =
 808                                                                         (ATOM_HPD_INT_RECORD *)
 809                                                                         record;
 810                                                                 gpio = radeon_lookup_gpio(rdev,
 811                                                                                           hpd_record->ucHPDIntGPIOID);
 812                                                                 hpd = radeon_atom_get_hpd_info_from_gpio(rdev, &gpio);
 813                                                                 hpd.plugged_state = hpd_record->ucPlugged_PinState;
 814                                                                 break;
 815                                                         }
 816                                                         record =
 817                                                             (ATOM_COMMON_RECORD_HEADER
 818                                                              *) ((char *)record
 819                                                                  +
 820                                                                  record->
 821                                                                  ucRecordSize);
 822                                                 }
 823                                                 break;
 824                                         }
 825                                 }
 826                         }
 827
 828                         /* needed for aux chan transactions */
 829                         ddc_bus.hpd = hpd.hpd;
 830
 831                         conn_id = le16_to_cpu(path->usConnObjectId);
 832
 833                         if (!radeon_atom_apply_quirks
 834                             (dev, le16_to_cpu(path->usDeviceTag), &connector_type,
 835                              &ddc_bus, &conn_id, &hpd))
 836                                 continue;
 837
 838                         radeon_add_atom_connector(dev,
 839                                                   conn_id,
 840                                                   le16_to_cpu(path->
 841                                                               usDeviceTag),
 842                                                   connector_type, &ddc_bus,
 843                                                   igp_lane_info,
 844                                                   connector_object_id,
 845                                                   &hpd,
 846                                                   &router);
 847
 848                 }
 849         }
 850
 851         radeon_link_encoder_connector(dev);
 852
 853         return true;
 854 }
 855
 856 static uint16_t atombios_get_connector_object_id(struct drm_device *dev,
 857                                                  int connector_type,
 858                                                  uint16_t devices)
 859 {
 860         struct radeon_device *rdev = dev->dev_private;
 861
 862         if (rdev->flags & RADEON_IS_IGP) {
 863                 return supported_devices_connector_object_id_convert
 864                         [connector_type];
 865         } else if (((connector_type == DRM_MODE_CONNECTOR_DVII) ||
 866                     (connector_type == DRM_MODE_CONNECTOR_DVID)) &&
 867                    (devices & ATOM_DEVICE_DFP2_SUPPORT))  {
 868                 struct radeon_mode_info *mode_info = &rdev->mode_info;
 869                 struct atom_context *ctx = mode_info->atom_context;
 870                 int index = GetIndexIntoMasterTable(DATA, XTMDS_Info);
 871                 uint16_t size, data_offset;
 872                 uint8_t frev, crev;
 873                 ATOM_XTMDS_INFO *xtmds;
 874
 875                 if (atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset)) {
 876                         xtmds = (ATOM_XTMDS_INFO *)(ctx->bios + data_offset);
 877
 878                         if (xtmds->ucSupportedLink & ATOM_XTMDS_SUPPORTED_DUALLINK) {
 879                                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
 880                                         return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I;
 881                                 else
 882                                         return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D;
 883                         } else {
 884                                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
 885                                         return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I;
 886                                 else
 887                                         return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D;
 888                         }
 889                 } else
 890                         return supported_devices_connector_object_id_convert
 891                                 [connector_type];
 892         } else {
 893                 return supported_devices_connector_object_id_convert
 894                         [connector_type];
 895         }
 896 }
 897
 898 struct bios_connector {
 899         bool valid;
 900         uint16_t line_mux;
 901         uint16_t devices;
 902         int connector_type;
 903         struct radeon_i2c_bus_rec ddc_bus;
 904         struct radeon_hpd hpd;
 905 };
 906
 907 bool radeon_get_atom_connector_info_from_supported_devices_table(struct
 908                                                                  drm_device
 909                                                                  *dev)
 910 {
 911         struct radeon_device *rdev = dev->dev_private;
 912         struct radeon_mode_info *mode_info = &rdev->mode_info;
 913         struct atom_context *ctx = mode_info->atom_context;
 914         int index = GetIndexIntoMasterTable(DATA, SupportedDevicesInfo);
 915         uint16_t size, data_offset;
 916         uint8_t frev, crev;
 917         uint16_t device_support;
 918         uint8_t dac;
 919         union atom_supported_devices *supported_devices;
 920         int i, j, max_device;
 921         struct bios_connector *bios_connectors;
 922         size_t bc_size = sizeof(*bios_connectors) * ATOM_MAX_SUPPORTED_DEVICE;
 923         struct radeon_router router;
 924
 925         router.ddc_valid = false;
 926         router.cd_valid = false;
 927
 928         bios_connectors = kzalloc(bc_size, GFP_KERNEL);
 929         if (!bios_connectors)
 930                 return false;
 931
 932         if (!atom_parse_data_header(ctx, index, &size, &frev, &crev,
 933                                     &data_offset)) {
 934                 kfree(bios_connectors);
 935                 return false;
 936         }
 937
 938         supported_devices =
 939             (union atom_supported_devices *)(ctx->bios + data_offset);
 940
 941         device_support = le16_to_cpu(supported_devices->info.usDeviceSupport);
 942
 943         if (frev > 1)
 944                 max_device = ATOM_MAX_SUPPORTED_DEVICE;
 945         else
 946                 max_device = ATOM_MAX_SUPPORTED_DEVICE_INFO;
 947
 948         for (i = 0; i < max_device; i++) {
 949                 ATOM_CONNECTOR_INFO_I2C ci =
 950                     supported_devices->info.asConnInfo[i];
 951
 952                 bios_connectors[i].valid = false;
 953
 954                 if (!(device_support & (1 << i))) {
 955                         continue;
 956                 }
 957
 958                 if (i == ATOM_DEVICE_CV_INDEX) {
 959                         DRM_DEBUG_KMS("Skipping Component Video\n");
 960                         continue;
 961                 }
 962
 963                 bios_connectors[i].connector_type =
 964                     supported_devices_connector_convert[ci.sucConnectorInfo.
 965                                                         sbfAccess.
 966                                                         bfConnectorType];
 967
 968                 if (bios_connectors[i].connector_type ==
 969                     DRM_MODE_CONNECTOR_Unknown)
 970                         continue;
 971
 972                 dac = ci.sucConnectorInfo.sbfAccess.bfAssociatedDAC;
 973
 974                 bios_connectors[i].line_mux =
 975                         ci.sucI2cId.ucAccess;
 976
 977                 /* give tv unique connector ids */
 978                 if (i == ATOM_DEVICE_TV1_INDEX) {
 979                         bios_connectors[i].ddc_bus.valid = false;
 980                         bios_connectors[i].line_mux = 50;
 981                 } else if (i == ATOM_DEVICE_TV2_INDEX) {
 982                         bios_connectors[i].ddc_bus.valid = false;
 983                         bios_connectors[i].line_mux = 51;
 984                 } else if (i == ATOM_DEVICE_CV_INDEX) {
 985                         bios_connectors[i].ddc_bus.valid = false;
 986                         bios_connectors[i].line_mux = 52;
 987                 } else
 988                         bios_connectors[i].ddc_bus =
 989                             radeon_lookup_i2c_gpio(rdev,
 990                                                    bios_connectors[i].line_mux);
 991
 992                 if ((crev > 1) && (frev > 1)) {
 993                         u8 isb = supported_devices->info_2d1.asIntSrcInfo[i].ucIntSrcBitmap;
 994                         switch (isb) {
 995                         case 0x4:
 996                                 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
 997                                 break;
 998                         case 0xa:
 999                                 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
1000                                 break;
1001                         default:
1002                                 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
1003                                 break;
1004                         }
1005                 } else {
1006                         if (i == ATOM_DEVICE_DFP1_INDEX)
1007                                 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
1008                         else if (i == ATOM_DEVICE_DFP2_INDEX)
1009                                 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
1010                         else
1011                                 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
1012                 }
1013
1014                 /* Always set the connector type to VGA for CRT1/CRT2. if they are
1015                  * shared with a DVI port, we'll pick up the DVI connector when we
1016                  * merge the outputs.  Some bioses incorrectly list VGA ports as DVI.
1017                  */
1018                 if (i == ATOM_DEVICE_CRT1_INDEX || i == ATOM_DEVICE_CRT2_INDEX)
1019                         bios_connectors[i].connector_type =
1020                             DRM_MODE_CONNECTOR_VGA;
1021
1022                 if (!radeon_atom_apply_quirks
1023                     (dev, (1 << i), &bios_connectors[i].connector_type,
1024                      &bios_connectors[i].ddc_bus, &bios_connectors[i].line_mux,
1025                      &bios_connectors[i].hpd))
1026                         continue;
1027
1028                 bios_connectors[i].valid = true;
1029                 bios_connectors[i].devices = (1 << i);
1030
1031                 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom)
1032                         radeon_add_atom_encoder(dev,
1033                                                 radeon_get_encoder_enum(dev,
1034                                                                       (1 << i),
1035                                                                       dac),
1036                                                 (1 << i),
1037                                                 0);
1038                 else
1039                         radeon_add_legacy_encoder(dev,
1040                                                   radeon_get_encoder_enum(dev,
1041                                                                         (1 << i),
1042                                                                         dac),
1043                                                   (1 << i));
1044         }
1045
1046         /* combine shared connectors */
1047         for (i = 0; i < max_device; i++) {
1048                 if (bios_connectors[i].valid) {
1049                         for (j = 0; j < max_device; j++) {
1050                                 if (bios_connectors[j].valid && (i != j)) {
1051                                         if (bios_connectors[i].line_mux ==
1052                                             bios_connectors[j].line_mux) {
1053                                                 /* make sure not to combine LVDS */
1054                                                 if (bios_connectors[i].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1055                                                         bios_connectors[i].line_mux = 53;
1056                                                         bios_connectors[i].ddc_bus.valid = false;
1057                                                         continue;
1058                                                 }
1059                                                 if (bios_connectors[j].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1060                                                         bios_connectors[j].line_mux = 53;
1061                                                         bios_connectors[j].ddc_bus.valid = false;
1062                                                         continue;
1063                                                 }
1064                                                 /* combine analog and digital for DVI-I */
1065                                                 if (((bios_connectors[i].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1066                                                      (bios_connectors[j].devices & (ATOM_DEVICE_CRT_SUPPORT))) ||
1067                                                     ((bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1068                                                      (bios_connectors[i].devices & (ATOM_DEVICE_CRT_SUPPORT)))) {
1069                                                         bios_connectors[i].devices |=
1070                                                                 bios_connectors[j].devices;
1071                                                         bios_connectors[i].connector_type =
1072                                                                 DRM_MODE_CONNECTOR_DVII;
1073                                                         if (bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT))
1074                                                                 bios_connectors[i].hpd =
1075                                                                         bios_connectors[j].hpd;
1076                                                         bios_connectors[j].valid = false;
1077                                                 }
1078                                         }
1079                                 }
1080                         }
1081                 }
1082         }
1083
1084         /* add the connectors */
1085         for (i = 0; i < max_device; i++) {
1086                 if (bios_connectors[i].valid) {
1087                         uint16_t connector_object_id =
1088                                 atombios_get_connector_object_id(dev,
1089                                                       bios_connectors[i].connector_type,
1090                                                       bios_connectors[i].devices);
1091                         radeon_add_atom_connector(dev,
1092                                                   bios_connectors[i].line_mux,
1093                                                   bios_connectors[i].devices,
1094                                                   bios_connectors[i].
1095                                                   connector_type,
1096                                                   &bios_connectors[i].ddc_bus,
1097                                                   0,
1098                                                   connector_object_id,
1099                                                   &bios_connectors[i].hpd,
1100                                                   &router);
1101                 }
1102         }
1103
1104         radeon_link_encoder_connector(dev);
1105
1106         kfree(bios_connectors);
1107         return true;
1108 }
1109
1110 union firmware_info {
1111         ATOM_FIRMWARE_INFO info;
1112         ATOM_FIRMWARE_INFO_V1_2 info_12;
1113         ATOM_FIRMWARE_INFO_V1_3 info_13;
1114         ATOM_FIRMWARE_INFO_V1_4 info_14;
1115         ATOM_FIRMWARE_INFO_V2_1 info_21;
1116         ATOM_FIRMWARE_INFO_V2_2 info_22;
1117 };
1118
1119 bool radeon_atom_get_clock_info(struct drm_device *dev)
1120 {
1121         struct radeon_device *rdev = dev->dev_private;
1122         struct radeon_mode_info *mode_info = &rdev->mode_info;
1123         int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
1124         union firmware_info *firmware_info;
1125         uint8_t frev, crev;
1126         struct radeon_pll *p1pll = &rdev->clock.p1pll;
1127         struct radeon_pll *p2pll = &rdev->clock.p2pll;
1128         struct radeon_pll *dcpll = &rdev->clock.dcpll;
1129         struct radeon_pll *spll = &rdev->clock.spll;
1130         struct radeon_pll *mpll = &rdev->clock.mpll;
1131         uint16_t data_offset;
1132
1133         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1134                                    &frev, &crev, &data_offset)) {
1135                 firmware_info =
1136                         (union firmware_info *)(mode_info->atom_context->bios +
1137                                                 data_offset);
1138                 /* pixel clocks */
1139                 p1pll->reference_freq =
1140                     le16_to_cpu(firmware_info->info.usReferenceClock);
1141                 p1pll->reference_div = 0;
1142
1143                 if (crev < 2)
1144                         p1pll->pll_out_min =
1145                                 le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Output);
1146                 else
1147                         p1pll->pll_out_min =
1148                                 le32_to_cpu(firmware_info->info_12.ulMinPixelClockPLL_Output);
1149                 p1pll->pll_out_max =
1150                     le32_to_cpu(firmware_info->info.ulMaxPixelClockPLL_Output);
1151
1152                 if (crev >= 4) {
1153                         p1pll->lcd_pll_out_min =
1154                                 le16_to_cpu(firmware_info->info_14.usLcdMinPixelClockPLL_Output) * 100;
1155                         if (p1pll->lcd_pll_out_min == 0)
1156                                 p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1157                         p1pll->lcd_pll_out_max =
1158                                 le16_to_cpu(firmware_info->info_14.usLcdMaxPixelClockPLL_Output) * 100;
1159                         if (p1pll->lcd_pll_out_max == 0)
1160                                 p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1161                 } else {
1162                         p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1163                         p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1164                 }
1165
1166                 if (p1pll->pll_out_min == 0) {
1167                         if (ASIC_IS_AVIVO(rdev))
1168                                 p1pll->pll_out_min = 64800;
1169                         else
1170                                 p1pll->pll_out_min = 20000;
1171                 }
1172
1173                 p1pll->pll_in_min =
1174                     le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Input);
1175                 p1pll->pll_in_max =
1176                     le16_to_cpu(firmware_info->info.usMaxPixelClockPLL_Input);
1177
1178                 *p2pll = *p1pll;
1179
1180                 /* system clock */
1181                 if (ASIC_IS_DCE4(rdev))
1182                         spll->reference_freq =
1183                                 le16_to_cpu(firmware_info->info_21.usCoreReferenceClock);
1184                 else
1185                         spll->reference_freq =
1186                                 le16_to_cpu(firmware_info->info.usReferenceClock);
1187                 spll->reference_div = 0;
1188
1189                 spll->pll_out_min =
1190                     le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Output);
1191                 spll->pll_out_max =
1192                     le32_to_cpu(firmware_info->info.ulMaxEngineClockPLL_Output);
1193
1194                 /* ??? */
1195                 if (spll->pll_out_min == 0) {
1196                         if (ASIC_IS_AVIVO(rdev))
1197                                 spll->pll_out_min = 64800;
1198                         else
1199                                 spll->pll_out_min = 20000;
1200                 }
1201
1202                 spll->pll_in_min =
1203                     le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Input);
1204                 spll->pll_in_max =
1205                     le16_to_cpu(firmware_info->info.usMaxEngineClockPLL_Input);
1206
1207                 /* memory clock */
1208                 if (ASIC_IS_DCE4(rdev))
1209                         mpll->reference_freq =
1210                                 le16_to_cpu(firmware_info->info_21.usMemoryReferenceClock);
1211                 else
1212                         mpll->reference_freq =
1213                                 le16_to_cpu(firmware_info->info.usReferenceClock);
1214                 mpll->reference_div = 0;
1215
1216                 mpll->pll_out_min =
1217                     le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Output);
1218                 mpll->pll_out_max =
1219                     le32_to_cpu(firmware_info->info.ulMaxMemoryClockPLL_Output);
1220
1221                 /* ??? */
1222                 if (mpll->pll_out_min == 0) {
1223                         if (ASIC_IS_AVIVO(rdev))
1224                                 mpll->pll_out_min = 64800;
1225                         else
1226                                 mpll->pll_out_min = 20000;
1227                 }
1228
1229                 mpll->pll_in_min =
1230                     le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Input);
1231                 mpll->pll_in_max =
1232                     le16_to_cpu(firmware_info->info.usMaxMemoryClockPLL_Input);
1233
1234                 rdev->clock.default_sclk =
1235                     le32_to_cpu(firmware_info->info.ulDefaultEngineClock);
1236                 rdev->clock.default_mclk =
1237                     le32_to_cpu(firmware_info->info.ulDefaultMemoryClock);
1238
1239                 if (ASIC_IS_DCE4(rdev)) {
1240                         rdev->clock.default_dispclk =
1241                                 le32_to_cpu(firmware_info->info_21.ulDefaultDispEngineClkFreq);
1242                         if (rdev->clock.default_dispclk == 0) {
1243                                 if (ASIC_IS_DCE5(rdev))
1244                                         rdev->clock.default_dispclk = 54000; /* 540 Mhz */
1245                                 else
1246                                         rdev->clock.default_dispclk = 60000; /* 600 Mhz */
1247                         }
1248                         rdev->clock.dp_extclk =
1249                                 le16_to_cpu(firmware_info->info_21.usUniphyDPModeExtClkFreq);
1250                 }
1251                 *dcpll = *p1pll;
1252
1253                 rdev->clock.max_pixel_clock = le16_to_cpu(firmware_info->info.usMaxPixelClock);
1254                 if (rdev->clock.max_pixel_clock == 0)
1255                         rdev->clock.max_pixel_clock = 40000;
1256
1257                 /* not technically a clock, but... */
1258                 rdev->mode_info.firmware_flags =
1259                         le16_to_cpu(firmware_info->info.usFirmwareCapability.susAccess);
1260
1261                 return true;
1262         }
1263
1264         return false;
1265 }
1266
1267 union igp_info {
1268         struct _ATOM_INTEGRATED_SYSTEM_INFO info;
1269         struct _ATOM_INTEGRATED_SYSTEM_INFO_V2 info_2;
1270         struct _ATOM_INTEGRATED_SYSTEM_INFO_V6 info_6;
1271         struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_7 info_7;
1272 };
1273
1274 bool radeon_atombios_sideport_present(struct radeon_device *rdev)
1275 {
1276         struct radeon_mode_info *mode_info = &rdev->mode_info;
1277         int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1278         union igp_info *igp_info;
1279         u8 frev, crev;
1280         u16 data_offset;
1281
1282         /* sideport is AMD only */
1283         if (rdev->family == CHIP_RS600)
1284                 return false;
1285
1286         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1287                                    &frev, &crev, &data_offset)) {
1288                 igp_info = (union igp_info *)(mode_info->atom_context->bios +
1289                                       data_offset);
1290                 switch (crev) {
1291                 case 1:
1292                         if (le32_to_cpu(igp_info->info.ulBootUpMemoryClock))
1293                                 return true;
1294                         break;
1295                 case 2:
1296                         if (le32_to_cpu(igp_info->info_2.ulBootUpSidePortClock))
1297                                 return true;
1298                         break;
1299                 default:
1300                         DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
1301                         break;
1302                 }
1303         }
1304         return false;
1305 }
1306
1307 bool radeon_atombios_get_tmds_info(struct radeon_encoder *encoder,
1308                                    struct radeon_encoder_int_tmds *tmds)
1309 {
1310         struct drm_device *dev = encoder->base.dev;
1311         struct radeon_device *rdev = dev->dev_private;
1312         struct radeon_mode_info *mode_info = &rdev->mode_info;
1313         int index = GetIndexIntoMasterTable(DATA, TMDS_Info);
1314         uint16_t data_offset;
1315         struct _ATOM_TMDS_INFO *tmds_info;
1316         uint8_t frev, crev;
1317         uint16_t maxfreq;
1318         int i;
1319
1320         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1321                                    &frev, &crev, &data_offset)) {
1322                 tmds_info =
1323                         (struct _ATOM_TMDS_INFO *)(mode_info->atom_context->bios +
1324                                                    data_offset);
1325
1326                 maxfreq = le16_to_cpu(tmds_info->usMaxFrequency);
1327                 for (i = 0; i < 4; i++) {
1328                         tmds->tmds_pll[i].freq =
1329                             le16_to_cpu(tmds_info->asMiscInfo[i].usFrequency);
1330                         tmds->tmds_pll[i].value =
1331                             tmds_info->asMiscInfo[i].ucPLL_ChargePump & 0x3f;
1332                         tmds->tmds_pll[i].value |=
1333                             (tmds_info->asMiscInfo[i].
1334                              ucPLL_VCO_Gain & 0x3f) << 6;
1335                         tmds->tmds_pll[i].value |=
1336                             (tmds_info->asMiscInfo[i].
1337                              ucPLL_DutyCycle & 0xf) << 12;
1338                         tmds->tmds_pll[i].value |=
1339                             (tmds_info->asMiscInfo[i].
1340                              ucPLL_VoltageSwing & 0xf) << 16;
1341
1342                         DRM_DEBUG_KMS("TMDS PLL From ATOMBIOS %u %x\n",
1343                                   tmds->tmds_pll[i].freq,
1344                                   tmds->tmds_pll[i].value);
1345
1346                         if (maxfreq == tmds->tmds_pll[i].freq) {
1347                                 tmds->tmds_pll[i].freq = 0xffffffff;
1348                                 break;
1349                         }
1350                 }
1351                 return true;
1352         }
1353         return false;
1354 }
1355
1356 bool radeon_atombios_get_ppll_ss_info(struct radeon_device *rdev,
1357                                       struct radeon_atom_ss *ss,
1358                                       int id)
1359 {
1360         struct radeon_mode_info *mode_info = &rdev->mode_info;
1361         int index = GetIndexIntoMasterTable(DATA, PPLL_SS_Info);
1362         uint16_t data_offset, size;
1363         struct _ATOM_SPREAD_SPECTRUM_INFO *ss_info;
1364         uint8_t frev, crev;
1365         int i, num_indices;
1366
1367         memset(ss, 0, sizeof(struct radeon_atom_ss));
1368         if (atom_parse_data_header(mode_info->atom_context, index, &size,
1369                                    &frev, &crev, &data_offset)) {
1370                 ss_info =
1371                         (struct _ATOM_SPREAD_SPECTRUM_INFO *)(mode_info->atom_context->bios + data_offset);
1372
1373                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1374                         sizeof(ATOM_SPREAD_SPECTRUM_ASSIGNMENT);
1375
1376                 for (i = 0; i < num_indices; i++) {
1377                         if (ss_info->asSS_Info[i].ucSS_Id == id) {
1378                                 ss->percentage =
1379                                         le16_to_cpu(ss_info->asSS_Info[i].usSpreadSpectrumPercentage);
1380                                 ss->type = ss_info->asSS_Info[i].ucSpreadSpectrumType;
1381                                 ss->step = ss_info->asSS_Info[i].ucSS_Step;
1382                                 ss->delay = ss_info->asSS_Info[i].ucSS_Delay;
1383                                 ss->range = ss_info->asSS_Info[i].ucSS_Range;
1384                                 ss->refdiv = ss_info->asSS_Info[i].ucRecommendedRef_Div;
1385                                 return true;
1386                         }
1387                 }
1388         }
1389         return false;
1390 }
1391
1392 static void radeon_atombios_get_igp_ss_overrides(struct radeon_device *rdev,
1393                                                  struct radeon_atom_ss *ss,
1394                                                  int id)
1395 {
1396         struct radeon_mode_info *mode_info = &rdev->mode_info;
1397         int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1398         u16 data_offset, size;
1399         union igp_info *igp_info;
1400         u8 frev, crev;
1401         u16 percentage = 0, rate = 0;
1402
1403         /* get any igp specific overrides */
1404         if (atom_parse_data_header(mode_info->atom_context, index, &size,
1405                                    &frev, &crev, &data_offset)) {
1406                 igp_info = (union igp_info *)
1407                         (mode_info->atom_context->bios + data_offset);
1408                 switch (crev) {
1409                 case 6:
1410                         switch (id) {
1411                         case ASIC_INTERNAL_SS_ON_TMDS:
1412                                 percentage = le16_to_cpu(igp_info->info_6.usDVISSPercentage);
1413                                 rate = le16_to_cpu(igp_info->info_6.usDVISSpreadRateIn10Hz);
1414                                 break;
1415                         case ASIC_INTERNAL_SS_ON_HDMI:
1416                                 percentage = le16_to_cpu(igp_info->info_6.usHDMISSPercentage);
1417                                 rate = le16_to_cpu(igp_info->info_6.usHDMISSpreadRateIn10Hz);
1418                                 break;
1419                         case ASIC_INTERNAL_SS_ON_LVDS:
1420                                 percentage = le16_to_cpu(igp_info->info_6.usLvdsSSPercentage);
1421                                 rate = le16_to_cpu(igp_info->info_6.usLvdsSSpreadRateIn10Hz);
1422                                 break;
1423                         }
1424                         break;
1425                 case 7:
1426                         switch (id) {
1427                         case ASIC_INTERNAL_SS_ON_TMDS:
1428                                 percentage = le16_to_cpu(igp_info->info_7.usDVISSPercentage);
1429                                 rate = le16_to_cpu(igp_info->info_7.usDVISSpreadRateIn10Hz);
1430                                 break;
1431                         case ASIC_INTERNAL_SS_ON_HDMI:
1432                                 percentage = le16_to_cpu(igp_info->info_7.usHDMISSPercentage);
1433                                 rate = le16_to_cpu(igp_info->info_7.usHDMISSpreadRateIn10Hz);
1434                                 break;
1435                         case ASIC_INTERNAL_SS_ON_LVDS:
1436                                 percentage = le16_to_cpu(igp_info->info_7.usLvdsSSPercentage);
1437                                 rate = le16_to_cpu(igp_info->info_7.usLvdsSSpreadRateIn10Hz);
1438                                 break;
1439                         }
1440                         break;
1441                 default:
1442                         DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
1443                         break;
1444                 }
1445                 if (percentage)
1446                         ss->percentage = percentage;
1447                 if (rate)
1448                         ss->rate = rate;
1449         }
1450 }
1451
1452 union asic_ss_info {
1453         struct _ATOM_ASIC_INTERNAL_SS_INFO info;
1454         struct _ATOM_ASIC_INTERNAL_SS_INFO_V2 info_2;
1455         struct _ATOM_ASIC_INTERNAL_SS_INFO_V3 info_3;
1456 };
1457
1458 bool radeon_atombios_get_asic_ss_info(struct radeon_device *rdev,
1459                                       struct radeon_atom_ss *ss,
1460                                       int id, u32 clock)
1461 {
1462         struct radeon_mode_info *mode_info = &rdev->mode_info;
1463         int index = GetIndexIntoMasterTable(DATA, ASIC_InternalSS_Info);
1464         uint16_t data_offset, size;
1465         union asic_ss_info *ss_info;
1466         uint8_t frev, crev;
1467         int i, num_indices;
1468
1469         memset(ss, 0, sizeof(struct radeon_atom_ss));
1470         if (atom_parse_data_header(mode_info->atom_context, index, &size,
1471                                    &frev, &crev, &data_offset)) {
1472
1473                 ss_info =
1474                         (union asic_ss_info *)(mode_info->atom_context->bios + data_offset);
1475
1476                 switch (frev) {
1477                 case 1:
1478                         num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1479                                 sizeof(ATOM_ASIC_SS_ASSIGNMENT);
1480
1481                         for (i = 0; i < num_indices; i++) {
1482                                 if ((ss_info->info.asSpreadSpectrum[i].ucClockIndication == id) &&
1483                                     (clock <= le32_to_cpu(ss_info->info.asSpreadSpectrum[i].ulTargetClockRange))) {
1484                                         ss->percentage =
1485                                                 le16_to_cpu(ss_info->info.asSpreadSpectrum[i].usSpreadSpectrumPercentage);
1486                                         ss->type = ss_info->info.asSpreadSpectrum[i].ucSpreadSpectrumMode;
1487                                         ss->rate = le16_to_cpu(ss_info->info.asSpreadSpectrum[i].usSpreadRateInKhz);
1488                                         return true;
1489                                 }
1490                         }
1491                         break;
1492                 case 2:
1493                         num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1494                                 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V2);
1495                         for (i = 0; i < num_indices; i++) {
1496                                 if ((ss_info->info_2.asSpreadSpectrum[i].ucClockIndication == id) &&
1497                                     (clock <= le32_to_cpu(ss_info->info_2.asSpreadSpectrum[i].ulTargetClockRange))) {
1498                                         ss->percentage =
1499                                                 le16_to_cpu(ss_info->info_2.asSpreadSpectrum[i].usSpreadSpectrumPercentage);
1500                                         ss->type = ss_info->info_2.asSpreadSpectrum[i].ucSpreadSpectrumMode;
1501                                         ss->rate = le16_to_cpu(ss_info->info_2.asSpreadSpectrum[i].usSpreadRateIn10Hz);
1502                                         return true;
1503                                 }
1504                         }
1505                         break;
1506                 case 3:
1507                         num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1508                                 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V3);
1509                         for (i = 0; i < num_indices; i++) {
1510                                 if ((ss_info->info_3.asSpreadSpectrum[i].ucClockIndication == id) &&
1511                                     (clock <= le32_to_cpu(ss_info->info_3.asSpreadSpectrum[i].ulTargetClockRange))) {
1512                                         ss->percentage =
1513                                                 le16_to_cpu(ss_info->info_3.asSpreadSpectrum[i].usSpreadSpectrumPercentage);
1514                                         ss->type = ss_info->info_3.asSpreadSpectrum[i].ucSpreadSpectrumMode;
1515                                         ss->rate = le16_to_cpu(ss_info->info_3.asSpreadSpectrum[i].usSpreadRateIn10Hz);
1516                                         if (rdev->flags & RADEON_IS_IGP)
1517                                                 radeon_atombios_get_igp_ss_overrides(rdev, ss, id);
1518                                         return true;
1519                                 }
1520                         }
1521                         break;
1522                 default:
1523                         DRM_ERROR("Unsupported ASIC_InternalSS_Info table: %d %d\n", frev, crev);
1524                         break;
1525                 }
1526
1527         }
1528         return false;
1529 }
1530
1531 union lvds_info {
1532         struct _ATOM_LVDS_INFO info;
1533         struct _ATOM_LVDS_INFO_V12 info_12;
1534 };
1535
1536 struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
1537                                                               radeon_encoder
1538                                                               *encoder)
1539 {
1540         struct drm_device *dev = encoder->base.dev;
1541         struct radeon_device *rdev = dev->dev_private;
1542         struct radeon_mode_info *mode_info = &rdev->mode_info;
1543         int index = GetIndexIntoMasterTable(DATA, LVDS_Info);
1544         uint16_t data_offset, misc;
1545         union lvds_info *lvds_info;
1546         uint8_t frev, crev;
1547         struct radeon_encoder_atom_dig *lvds = NULL;
1548         int encoder_enum = (encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
1549
1550         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1551                                    &frev, &crev, &data_offset)) {
1552                 lvds_info =
1553                         (union lvds_info *)(mode_info->atom_context->bios + data_offset);
1554                 lvds =
1555                     kzalloc(sizeof(struct radeon_encoder_atom_dig), GFP_KERNEL);
1556
1557                 if (!lvds)
1558                         return NULL;
1559
1560                 lvds->native_mode.clock =
1561                     le16_to_cpu(lvds_info->info.sLCDTiming.usPixClk) * 10;
1562                 lvds->native_mode.hdisplay =
1563                     le16_to_cpu(lvds_info->info.sLCDTiming.usHActive);
1564                 lvds->native_mode.vdisplay =
1565                     le16_to_cpu(lvds_info->info.sLCDTiming.usVActive);
1566                 lvds->native_mode.htotal = lvds->native_mode.hdisplay +
1567                         le16_to_cpu(lvds_info->info.sLCDTiming.usHBlanking_Time);
1568                 lvds->native_mode.hsync_start = lvds->native_mode.hdisplay +
1569                         le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncOffset);
1570                 lvds->native_mode.hsync_end = lvds->native_mode.hsync_start +
1571                         le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncWidth);
1572                 lvds->native_mode.vtotal = lvds->native_mode.vdisplay +
1573                         le16_to_cpu(lvds_info->info.sLCDTiming.usVBlanking_Time);
1574                 lvds->native_mode.vsync_start = lvds->native_mode.vdisplay +
1575                         le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncOffset);
1576                 lvds->native_mode.vsync_end = lvds->native_mode.vsync_start +
1577                         le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncWidth);
1578                 lvds->panel_pwr_delay =
1579                     le16_to_cpu(lvds_info->info.usOffDelayInMs);
1580                 lvds->lcd_misc = lvds_info->info.ucLVDS_Misc;
1581
1582                 misc = le16_to_cpu(lvds_info->info.sLCDTiming.susModeMiscInfo.usAccess);
1583                 if (misc & ATOM_VSYNC_POLARITY)
1584                         lvds->native_mode.flags |= DRM_MODE_FLAG_NVSYNC;
1585                 if (misc & ATOM_HSYNC_POLARITY)
1586                         lvds->native_mode.flags |= DRM_MODE_FLAG_NHSYNC;
1587                 if (misc & ATOM_COMPOSITESYNC)
1588                         lvds->native_mode.flags |= DRM_MODE_FLAG_CSYNC;
1589                 if (misc & ATOM_INTERLACE)
1590                         lvds->native_mode.flags |= DRM_MODE_FLAG_INTERLACE;
1591                 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1592                         lvds->native_mode.flags |= DRM_MODE_FLAG_DBLSCAN;
1593
1594                 lvds->native_mode.width_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageHSize);
1595                 lvds->native_mode.height_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageVSize);
1596
1597                 /* set crtc values */
1598                 drm_mode_set_crtcinfo(&lvds->native_mode, CRTC_INTERLACE_HALVE_V);
1599
1600                 lvds->lcd_ss_id = lvds_info->info.ucSS_Id;
1601
1602                 encoder->native_mode = lvds->native_mode;
1603
1604                 if (encoder_enum == 2)
1605                         lvds->linkb = true;
1606                 else
1607                         lvds->linkb = false;
1608
1609                 /* parse the lcd record table */
1610                 if (le16_to_cpu(lvds_info->info.usModePatchTableOffset)) {
1611                         ATOM_FAKE_EDID_PATCH_RECORD *fake_edid_record;
1612                         ATOM_PANEL_RESOLUTION_PATCH_RECORD *panel_res_record;
1613                         bool bad_record = false;
1614                         u8 *record;
1615
1616                         if ((frev == 1) && (crev < 2))
1617                                 /* absolute */
1618                                 record = (u8 *)(mode_info->atom_context->bios +
1619                                                 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1620                         else
1621                                 /* relative */
1622                                 record = (u8 *)(mode_info->atom_context->bios +
1623                                                 data_offset +
1624                                                 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1625                         while (*record != ATOM_RECORD_END_TYPE) {
1626                                 switch (*record) {
1627                                 case LCD_MODE_PATCH_RECORD_MODE_TYPE:
1628                                         record += sizeof(ATOM_PATCH_RECORD_MODE);
1629                                         break;
1630                                 case LCD_RTS_RECORD_TYPE:
1631                                         record += sizeof(ATOM_LCD_RTS_RECORD);
1632                                         break;
1633                                 case LCD_CAP_RECORD_TYPE:
1634                                         record += sizeof(ATOM_LCD_MODE_CONTROL_CAP);
1635                                         break;
1636                                 case LCD_FAKE_EDID_PATCH_RECORD_TYPE:
1637                                         fake_edid_record = (ATOM_FAKE_EDID_PATCH_RECORD *)record;
1638                                         if (fake_edid_record->ucFakeEDIDLength) {
1639                                                 struct edid *edid;
1640                                                 int edid_size =
1641                                                         max((int)EDID_LENGTH, (int)fake_edid_record->ucFakeEDIDLength);
1642                                                 edid = kmalloc(edid_size, GFP_KERNEL);
1643                                                 if (edid) {
1644                                                         memcpy((u8 *)edid, (u8 *)&fake_edid_record->ucFakeEDIDString[0],
1645                                                                fake_edid_record->ucFakeEDIDLength);
1646
1647                                                         if (drm_edid_is_valid(edid)) {
1648                                                                 rdev->mode_info.bios_hardcoded_edid = edid;
1649                                                                 rdev->mode_info.bios_hardcoded_edid_size = edid_size;
1650                                                         } else
1651                                                                 kfree(edid);
1652                                                 }
1653                                         }
1654                                         record += sizeof(ATOM_FAKE_EDID_PATCH_RECORD);
1655                                         break;
1656                                 case LCD_PANEL_RESOLUTION_RECORD_TYPE:
1657                                         panel_res_record = (ATOM_PANEL_RESOLUTION_PATCH_RECORD *)record;
1658                                         lvds->native_mode.width_mm = panel_res_record->usHSize;
1659                                         lvds->native_mode.height_mm = panel_res_record->usVSize;
1660                                         record += sizeof(ATOM_PANEL_RESOLUTION_PATCH_RECORD);
1661                                         break;
1662                                 default:
1663                                         DRM_ERROR("Bad LCD record %d\n", *record);
1664                                         bad_record = true;
1665                                         break;
1666                                 }
1667                                 if (bad_record)
1668                                         break;
1669                         }
1670                 }
1671         }
1672         return lvds;
1673 }
1674
1675 struct radeon_encoder_primary_dac *
1676 radeon_atombios_get_primary_dac_info(struct radeon_encoder *encoder)
1677 {
1678         struct drm_device *dev = encoder->base.dev;
1679         struct radeon_device *rdev = dev->dev_private;
1680         struct radeon_mode_info *mode_info = &rdev->mode_info;
1681         int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1682         uint16_t data_offset;
1683         struct _COMPASSIONATE_DATA *dac_info;
1684         uint8_t frev, crev;
1685         uint8_t bg, dac;
1686         struct radeon_encoder_primary_dac *p_dac = NULL;
1687
1688         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1689                                    &frev, &crev, &data_offset)) {
1690                 dac_info = (struct _COMPASSIONATE_DATA *)
1691                         (mode_info->atom_context->bios + data_offset);
1692
1693                 p_dac = kzalloc(sizeof(struct radeon_encoder_primary_dac), GFP_KERNEL);
1694
1695                 if (!p_dac)
1696                         return NULL;
1697
1698                 bg = dac_info->ucDAC1_BG_Adjustment;
1699                 dac = dac_info->ucDAC1_DAC_Adjustment;
1700                 p_dac->ps2_pdac_adj = (bg << 8) | (dac);
1701
1702         }
1703         return p_dac;
1704 }
1705
1706 bool radeon_atom_get_tv_timings(struct radeon_device *rdev, int index,
1707                                 struct drm_display_mode *mode)
1708 {
1709         struct radeon_mode_info *mode_info = &rdev->mode_info;
1710         ATOM_ANALOG_TV_INFO *tv_info;
1711         ATOM_ANALOG_TV_INFO_V1_2 *tv_info_v1_2;
1712         ATOM_DTD_FORMAT *dtd_timings;
1713         int data_index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1714         u8 frev, crev;
1715         u16 data_offset, misc;
1716
1717         if (!atom_parse_data_header(mode_info->atom_context, data_index, NULL,
1718                                     &frev, &crev, &data_offset))
1719                 return false;
1720
1721         switch (crev) {
1722         case 1:
1723                 tv_info = (ATOM_ANALOG_TV_INFO *)(mode_info->atom_context->bios + data_offset);
1724                 if (index >= MAX_SUPPORTED_TV_TIMING)
1725                         return false;
1726
1727                 mode->crtc_htotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Total);
1728                 mode->crtc_hdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Disp);
1729                 mode->crtc_hsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart);
1730                 mode->crtc_hsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart) +
1731                         le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncWidth);
1732
1733                 mode->crtc_vtotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Total);
1734                 mode->crtc_vdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Disp);
1735                 mode->crtc_vsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart);
1736                 mode->crtc_vsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart) +
1737                         le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncWidth);
1738
1739                 mode->flags = 0;
1740                 misc = le16_to_cpu(tv_info->aModeTimings[index].susModeMiscInfo.usAccess);
1741                 if (misc & ATOM_VSYNC_POLARITY)
1742                         mode->flags |= DRM_MODE_FLAG_NVSYNC;
1743                 if (misc & ATOM_HSYNC_POLARITY)
1744                         mode->flags |= DRM_MODE_FLAG_NHSYNC;
1745                 if (misc & ATOM_COMPOSITESYNC)
1746                         mode->flags |= DRM_MODE_FLAG_CSYNC;
1747                 if (misc & ATOM_INTERLACE)
1748                         mode->flags |= DRM_MODE_FLAG_INTERLACE;
1749                 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1750                         mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1751
1752                 mode->clock = le16_to_cpu(tv_info->aModeTimings[index].usPixelClock) * 10;
1753
1754                 if (index == 1) {
1755                         /* PAL timings appear to have wrong values for totals */
1756                         mode->crtc_htotal -= 1;
1757                         mode->crtc_vtotal -= 1;
1758                 }
1759                 break;
1760         case 2:
1761                 tv_info_v1_2 = (ATOM_ANALOG_TV_INFO_V1_2 *)(mode_info->atom_context->bios + data_offset);
1762                 if (index >= MAX_SUPPORTED_TV_TIMING_V1_2)
1763                         return false;
1764
1765                 dtd_timings = &tv_info_v1_2->aModeTimings[index];
1766                 mode->crtc_htotal = le16_to_cpu(dtd_timings->usHActive) +
1767                         le16_to_cpu(dtd_timings->usHBlanking_Time);
1768                 mode->crtc_hdisplay = le16_to_cpu(dtd_timings->usHActive);
1769                 mode->crtc_hsync_start = le16_to_cpu(dtd_timings->usHActive) +
1770                         le16_to_cpu(dtd_timings->usHSyncOffset);
1771                 mode->crtc_hsync_end = mode->crtc_hsync_start +
1772                         le16_to_cpu(dtd_timings->usHSyncWidth);
1773
1774                 mode->crtc_vtotal = le16_to_cpu(dtd_timings->usVActive) +
1775                         le16_to_cpu(dtd_timings->usVBlanking_Time);
1776                 mode->crtc_vdisplay = le16_to_cpu(dtd_timings->usVActive);
1777                 mode->crtc_vsync_start = le16_to_cpu(dtd_timings->usVActive) +
1778                         le16_to_cpu(dtd_timings->usVSyncOffset);
1779                 mode->crtc_vsync_end = mode->crtc_vsync_start +
1780                         le16_to_cpu(dtd_timings->usVSyncWidth);
1781
1782                 mode->flags = 0;
1783                 misc = le16_to_cpu(dtd_timings->susModeMiscInfo.usAccess);
1784                 if (misc & ATOM_VSYNC_POLARITY)
1785                         mode->flags |= DRM_MODE_FLAG_NVSYNC;
1786                 if (misc & ATOM_HSYNC_POLARITY)
1787                         mode->flags |= DRM_MODE_FLAG_NHSYNC;
1788                 if (misc & ATOM_COMPOSITESYNC)
1789                         mode->flags |= DRM_MODE_FLAG_CSYNC;
1790                 if (misc & ATOM_INTERLACE)
1791                         mode->flags |= DRM_MODE_FLAG_INTERLACE;
1792                 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1793                         mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1794
1795                 mode->clock = le16_to_cpu(dtd_timings->usPixClk) * 10;
1796                 break;
1797         }
1798         return true;
1799 }
1800
1801 enum radeon_tv_std
1802 radeon_atombios_get_tv_info(struct radeon_device *rdev)
1803 {
1804         struct radeon_mode_info *mode_info = &rdev->mode_info;
1805         int index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1806         uint16_t data_offset;
1807         uint8_t frev, crev;
1808         struct _ATOM_ANALOG_TV_INFO *tv_info;
1809         enum radeon_tv_std tv_std = TV_STD_NTSC;
1810
1811         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1812                                    &frev, &crev, &data_offset)) {
1813
1814                 tv_info = (struct _ATOM_ANALOG_TV_INFO *)
1815                         (mode_info->atom_context->bios + data_offset);
1816
1817                 switch (tv_info->ucTV_BootUpDefaultStandard) {
1818                 case ATOM_TV_NTSC:
1819                         tv_std = TV_STD_NTSC;
1820                         DRM_DEBUG_KMS("Default TV standard: NTSC\n");
1821                         break;
1822                 case ATOM_TV_NTSCJ:
1823                         tv_std = TV_STD_NTSC_J;
1824                         DRM_DEBUG_KMS("Default TV standard: NTSC-J\n");
1825                         break;
1826                 case ATOM_TV_PAL:
1827                         tv_std = TV_STD_PAL;
1828                         DRM_DEBUG_KMS("Default TV standard: PAL\n");
1829                         break;
1830                 case ATOM_TV_PALM:
1831                         tv_std = TV_STD_PAL_M;
1832                         DRM_DEBUG_KMS("Default TV standard: PAL-M\n");
1833                         break;
1834                 case ATOM_TV_PALN:
1835                         tv_std = TV_STD_PAL_N;
1836                         DRM_DEBUG_KMS("Default TV standard: PAL-N\n");
1837                         break;
1838                 case ATOM_TV_PALCN:
1839                         tv_std = TV_STD_PAL_CN;
1840                         DRM_DEBUG_KMS("Default TV standard: PAL-CN\n");
1841                         break;
1842                 case ATOM_TV_PAL60:
1843                         tv_std = TV_STD_PAL_60;
1844                         DRM_DEBUG_KMS("Default TV standard: PAL-60\n");
1845                         break;
1846                 case ATOM_TV_SECAM:
1847                         tv_std = TV_STD_SECAM;
1848                         DRM_DEBUG_KMS("Default TV standard: SECAM\n");
1849                         break;
1850                 default:
1851                         tv_std = TV_STD_NTSC;
1852                         DRM_DEBUG_KMS("Unknown TV standard; defaulting to NTSC\n");
1853                         break;
1854                 }
1855         }
1856         return tv_std;
1857 }
1858
1859 struct radeon_encoder_tv_dac *
1860 radeon_atombios_get_tv_dac_info(struct radeon_encoder *encoder)
1861 {
1862         struct drm_device *dev = encoder->base.dev;
1863         struct radeon_device *rdev = dev->dev_private;
1864         struct radeon_mode_info *mode_info = &rdev->mode_info;
1865         int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1866         uint16_t data_offset;
1867         struct _COMPASSIONATE_DATA *dac_info;
1868         uint8_t frev, crev;
1869         uint8_t bg, dac;
1870         struct radeon_encoder_tv_dac *tv_dac = NULL;
1871
1872         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1873                                    &frev, &crev, &data_offset)) {
1874
1875                 dac_info = (struct _COMPASSIONATE_DATA *)
1876                         (mode_info->atom_context->bios + data_offset);
1877
1878                 tv_dac = kzalloc(sizeof(struct radeon_encoder_tv_dac), GFP_KERNEL);
1879
1880                 if (!tv_dac)
1881                         return NULL;
1882
1883                 bg = dac_info->ucDAC2_CRT2_BG_Adjustment;
1884                 dac = dac_info->ucDAC2_CRT2_DAC_Adjustment;
1885                 tv_dac->ps2_tvdac_adj = (bg << 16) | (dac << 20);
1886
1887                 bg = dac_info->ucDAC2_PAL_BG_Adjustment;
1888                 dac = dac_info->ucDAC2_PAL_DAC_Adjustment;
1889                 tv_dac->pal_tvdac_adj = (bg << 16) | (dac << 20);
1890
1891                 bg = dac_info->ucDAC2_NTSC_BG_Adjustment;
1892                 dac = dac_info->ucDAC2_NTSC_DAC_Adjustment;
1893                 tv_dac->ntsc_tvdac_adj = (bg << 16) | (dac << 20);
1894
1895                 tv_dac->tv_std = radeon_atombios_get_tv_info(rdev);
1896         }
1897         return tv_dac;
1898 }
1899
1900 static const char *thermal_controller_names[] = {
1901         "NONE",
1902         "lm63",
1903         "adm1032",
1904         "adm1030",
1905         "max6649",
1906         "lm64",
1907         "f75375",
1908         "asc7xxx",
1909 };
1910
1911 static const char *pp_lib_thermal_controller_names[] = {
1912         "NONE",
1913         "lm63",
1914         "adm1032",
1915         "adm1030",
1916         "max6649",
1917         "lm64",
1918         "f75375",
1919         "RV6xx",
1920         "RV770",
1921         "adt7473",
1922         "NONE",
1923         "External GPIO",
1924         "Evergreen",
1925         "emc2103",
1926         "Sumo",
1927         "Northern Islands",
1928         "Southern Islands",
1929         "lm96163",
1930 };
1931
1932 union power_info {
1933         struct _ATOM_POWERPLAY_INFO info;
1934         struct _ATOM_POWERPLAY_INFO_V2 info_2;
1935         struct _ATOM_POWERPLAY_INFO_V3 info_3;
1936         struct _ATOM_PPLIB_POWERPLAYTABLE pplib;
1937         struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2;
1938         struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3;
1939 };
1940
1941 union pplib_clock_info {
1942         struct _ATOM_PPLIB_R600_CLOCK_INFO r600;
1943         struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780;
1944         struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen;
1945         struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo;
1946         struct _ATOM_PPLIB_SI_CLOCK_INFO si;
1947 };
1948
1949 union pplib_power_state {
1950         struct _ATOM_PPLIB_STATE v1;
1951         struct _ATOM_PPLIB_STATE_V2 v2;
1952 };
1953
1954 static void radeon_atombios_parse_misc_flags_1_3(struct radeon_device *rdev,
1955                                                  int state_index,
1956                                                  u32 misc, u32 misc2)
1957 {
1958         rdev->pm.power_state[state_index].misc = misc;
1959         rdev->pm.power_state[state_index].misc2 = misc2;
1960         /* order matters! */
1961         if (misc & ATOM_PM_MISCINFO_POWER_SAVING_MODE)
1962                 rdev->pm.power_state[state_index].type =
1963                         POWER_STATE_TYPE_POWERSAVE;
1964         if (misc & ATOM_PM_MISCINFO_DEFAULT_DC_STATE_ENTRY_TRUE)
1965                 rdev->pm.power_state[state_index].type =
1966                         POWER_STATE_TYPE_BATTERY;
1967         if (misc & ATOM_PM_MISCINFO_DEFAULT_LOW_DC_STATE_ENTRY_TRUE)
1968                 rdev->pm.power_state[state_index].type =
1969                         POWER_STATE_TYPE_BATTERY;
1970         if (misc & ATOM_PM_MISCINFO_LOAD_BALANCE_EN)
1971                 rdev->pm.power_state[state_index].type =
1972                         POWER_STATE_TYPE_BALANCED;
1973         if (misc & ATOM_PM_MISCINFO_3D_ACCELERATION_EN) {
1974                 rdev->pm.power_state[state_index].type =
1975                         POWER_STATE_TYPE_PERFORMANCE;
1976                 rdev->pm.power_state[state_index].flags &=
1977                         ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
1978         }
1979         if (misc2 & ATOM_PM_MISCINFO2_SYSTEM_AC_LITE_MODE)
1980                 rdev->pm.power_state[state_index].type =
1981                         POWER_STATE_TYPE_BALANCED;
1982         if (misc & ATOM_PM_MISCINFO_DRIVER_DEFAULT_MODE) {
1983                 rdev->pm.power_state[state_index].type =
1984                         POWER_STATE_TYPE_DEFAULT;
1985                 rdev->pm.default_power_state_index = state_index;
1986                 rdev->pm.power_state[state_index].default_clock_mode =
1987                         &rdev->pm.power_state[state_index].clock_info[0];
1988         } else if (state_index == 0) {
1989                 rdev->pm.power_state[state_index].clock_info[0].flags |=
1990                         RADEON_PM_MODE_NO_DISPLAY;
1991         }
1992 }
1993
1994 static int radeon_atombios_parse_power_table_1_3(struct radeon_device *rdev)
1995 {
1996         struct radeon_mode_info *mode_info = &rdev->mode_info;
1997         u32 misc, misc2 = 0;
1998         int num_modes = 0, i;
1999         int state_index = 0;
2000         struct radeon_i2c_bus_rec i2c_bus;
2001         union power_info *power_info;
2002         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2003         u16 data_offset;
2004         u8 frev, crev;
2005
2006         if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2007                                    &frev, &crev, &data_offset))
2008                 return state_index;
2009         power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2010
2011         /* add the i2c bus for thermal/fan chip */
2012         if ((power_info->info.ucOverdriveThermalController > 0) &&
2013             (power_info->info.ucOverdriveThermalController < ARRAY_SIZE(thermal_controller_names))) {
2014                 DRM_INFO("Possible %s thermal controller at 0x%02x\n",
2015                          thermal_controller_names[power_info->info.ucOverdriveThermalController],
2016                          power_info->info.ucOverdriveControllerAddress >> 1);
2017                 i2c_bus = radeon_lookup_i2c_gpio(rdev, power_info->info.ucOverdriveI2cLine);
2018                 rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
2019                 if (rdev->pm.i2c_bus) {
2020                         struct i2c_board_info info = { };
2021                         const char *name = thermal_controller_names[power_info->info.
2022                                                                     ucOverdriveThermalController];
2023                         info.addr = power_info->info.ucOverdriveControllerAddress >> 1;
2024                         strlcpy(info.type, name, sizeof(info.type));
2025                         i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
2026                 }
2027         }
2028         num_modes = power_info->info.ucNumOfPowerModeEntries;
2029         if (num_modes > ATOM_MAX_NUMBEROF_POWER_BLOCK)
2030                 num_modes = ATOM_MAX_NUMBEROF_POWER_BLOCK;
2031         rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) * num_modes, GFP_KERNEL);
2032         if (!rdev->pm.power_state)
2033                 return state_index;
2034         /* last mode is usually default, array is low to high */
2035         for (i = 0; i < num_modes; i++) {
2036                 rdev->pm.power_state[state_index].clock_info =
2037                         kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL);
2038                 if (!rdev->pm.power_state[state_index].clock_info)
2039                         return state_index;
2040                 rdev->pm.power_state[state_index].num_clock_modes = 1;
2041                 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2042                 switch (frev) {
2043                 case 1:
2044                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2045                                 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usMemoryClock);
2046                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2047                                 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usEngineClock);
2048                         /* skip invalid modes */
2049                         if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2050                             (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2051                                 continue;
2052                         rdev->pm.power_state[state_index].pcie_lanes =
2053                                 power_info->info.asPowerPlayInfo[i].ucNumPciELanes;
2054                         misc = le32_to_cpu(power_info->info.asPowerPlayInfo[i].ulMiscInfo);
2055                         if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2056                             (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2057                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2058                                         VOLTAGE_GPIO;
2059                                 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2060                                         radeon_lookup_gpio(rdev,
2061                                                            power_info->info.asPowerPlayInfo[i].ucVoltageDropIndex);
2062                                 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2063                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2064                                                 true;
2065                                 else
2066                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2067                                                 false;
2068                         } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2069                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2070                                         VOLTAGE_VDDC;
2071                                 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2072                                         power_info->info.asPowerPlayInfo[i].ucVoltageDropIndex;
2073                         }
2074                         rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2075                         radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, 0);
2076                         state_index++;
2077                         break;
2078                 case 2:
2079                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2080                                 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMemoryClock);
2081                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2082                                 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulEngineClock);
2083                         /* skip invalid modes */
2084                         if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2085                             (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2086                                 continue;
2087                         rdev->pm.power_state[state_index].pcie_lanes =
2088                                 power_info->info_2.asPowerPlayInfo[i].ucNumPciELanes;
2089                         misc = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo);
2090                         misc2 = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo2);
2091                         if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2092                             (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2093                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2094                                         VOLTAGE_GPIO;
2095                                 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2096                                         radeon_lookup_gpio(rdev,
2097                                                            power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex);
2098                                 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2099                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2100                                                 true;
2101                                 else
2102                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2103                                                 false;
2104                         } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2105                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2106                                         VOLTAGE_VDDC;
2107                                 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2108                                         power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex;
2109                         }
2110                         rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2111                         radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2112                         state_index++;
2113                         break;
2114                 case 3:
2115                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2116                                 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMemoryClock);
2117                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2118                                 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulEngineClock);
2119                         /* skip invalid modes */
2120                         if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2121                             (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2122                                 continue;
2123                         rdev->pm.power_state[state_index].pcie_lanes =
2124                                 power_info->info_3.asPowerPlayInfo[i].ucNumPciELanes;
2125                         misc = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo);
2126                         misc2 = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo2);
2127                         if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2128                             (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2129                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2130                                         VOLTAGE_GPIO;
2131                                 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2132                                         radeon_lookup_gpio(rdev,
2133                                                            power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex);
2134                                 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2135                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2136                                                 true;
2137                                 else
2138                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2139                                                 false;
2140                         } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2141                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2142                                         VOLTAGE_VDDC;
2143                                 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2144                                         power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex;
2145                                 if (misc2 & ATOM_PM_MISCINFO2_VDDCI_DYNAMIC_VOLTAGE_EN) {
2146                                         rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_enabled =
2147                                                 true;
2148                                         rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_id =
2149                                                 power_info->info_3.asPowerPlayInfo[i].ucVDDCI_VoltageDropIndex;
2150                                 }
2151                         }
2152                         rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2153                         radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2154                         state_index++;
2155                         break;
2156                 }
2157         }
2158         /* last mode is usually default */
2159         if (rdev->pm.default_power_state_index == -1) {
2160                 rdev->pm.power_state[state_index - 1].type =
2161                         POWER_STATE_TYPE_DEFAULT;
2162                 rdev->pm.default_power_state_index = state_index - 1;
2163                 rdev->pm.power_state[state_index - 1].default_clock_mode =
2164                         &rdev->pm.power_state[state_index - 1].clock_info[0];
2165                 rdev->pm.power_state[state_index].flags &=
2166                         ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2167                 rdev->pm.power_state[state_index].misc = 0;
2168                 rdev->pm.power_state[state_index].misc2 = 0;
2169         }
2170         return state_index;
2171 }
2172
2173 static void radeon_atombios_add_pplib_thermal_controller(struct radeon_device *rdev,
2174                                                          ATOM_PPLIB_THERMALCONTROLLER *controller)
2175 {
2176         struct radeon_i2c_bus_rec i2c_bus;
2177
2178         /* add the i2c bus for thermal/fan chip */
2179         if (controller->ucType > 0) {
2180                 if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV6xx) {
2181                         DRM_INFO("Internal thermal controller %s fan control\n",
2182                                  (controller->ucFanParameters &
2183                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2184                         rdev->pm.int_thermal_type = THERMAL_TYPE_RV6XX;
2185                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV770) {
2186                         DRM_INFO("Internal thermal controller %s fan control\n",
2187                                  (controller->ucFanParameters &
2188                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2189                         rdev->pm.int_thermal_type = THERMAL_TYPE_RV770;
2190                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_EVERGREEN) {
2191                         DRM_INFO("Internal thermal controller %s fan control\n",
2192                                  (controller->ucFanParameters &
2193                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2194                         rdev->pm.int_thermal_type = THERMAL_TYPE_EVERGREEN;
2195                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_SUMO) {
2196                         DRM_INFO("Internal thermal controller %s fan control\n",
2197                                  (controller->ucFanParameters &
2198                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2199                         rdev->pm.int_thermal_type = THERMAL_TYPE_SUMO;
2200                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_NISLANDS) {
2201                         DRM_INFO("Internal thermal controller %s fan control\n",
2202                                  (controller->ucFanParameters &
2203                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2204                         rdev->pm.int_thermal_type = THERMAL_TYPE_NI;
2205                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_SISLANDS) {
2206                         DRM_INFO("Internal thermal controller %s fan control\n",
2207                                  (controller->ucFanParameters &
2208                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2209                         rdev->pm.int_thermal_type = THERMAL_TYPE_SI;
2210                 } else if ((controller->ucType ==
2211                             ATOM_PP_THERMALCONTROLLER_EXTERNAL_GPIO) ||
2212                            (controller->ucType ==
2213                             ATOM_PP_THERMALCONTROLLER_ADT7473_WITH_INTERNAL) ||
2214                            (controller->ucType ==
2215                             ATOM_PP_THERMALCONTROLLER_EMC2103_WITH_INTERNAL)) {
2216                         DRM_INFO("Special thermal controller config\n");
2217                 } else if (controller->ucType < ARRAY_SIZE(pp_lib_thermal_controller_names)) {
2218                         DRM_INFO("Possible %s thermal controller at 0x%02x %s fan control\n",
2219                                  pp_lib_thermal_controller_names[controller->ucType],
2220                                  controller->ucI2cAddress >> 1,
2221                                  (controller->ucFanParameters &
2222                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2223                         i2c_bus = radeon_lookup_i2c_gpio(rdev, controller->ucI2cLine);
2224                         rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
2225                         if (rdev->pm.i2c_bus) {
2226                                 struct i2c_board_info info = { };
2227                                 const char *name = pp_lib_thermal_controller_names[controller->ucType];
2228                                 info.addr = controller->ucI2cAddress >> 1;
2229                                 strlcpy(info.type, name, sizeof(info.type));
2230                                 i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
2231                         }
2232                 } else {
2233                         DRM_INFO("Unknown thermal controller type %d at 0x%02x %s fan control\n",
2234                                  controller->ucType,
2235                                  controller->ucI2cAddress >> 1,
2236                                  (controller->ucFanParameters &
2237                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2238                 }
2239         }
2240 }
2241
2242 static void radeon_atombios_get_default_voltages(struct radeon_device *rdev,
2243                                                  u16 *vddc, u16 *vddci)
2244 {
2245         struct radeon_mode_info *mode_info = &rdev->mode_info;
2246         int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
2247         u8 frev, crev;
2248         u16 data_offset;
2249         union firmware_info *firmware_info;
2250
2251         *vddc = 0;
2252         *vddci = 0;
2253
2254         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2255                                    &frev, &crev, &data_offset)) {
2256                 firmware_info =
2257                         (union firmware_info *)(mode_info->atom_context->bios +
2258                                                 data_offset);
2259                 *vddc = le16_to_cpu(firmware_info->info_14.usBootUpVDDCVoltage);
2260                 if ((frev == 2) && (crev >= 2))
2261                         *vddci = le16_to_cpu(firmware_info->info_22.usBootUpVDDCIVoltage);
2262         }
2263 }
2264
2265 static void radeon_atombios_parse_pplib_non_clock_info(struct radeon_device *rdev,
2266                                                        int state_index, int mode_index,
2267                                                        struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info)
2268 {
2269         int j;
2270         u32 misc = le32_to_cpu(non_clock_info->ulCapsAndSettings);
2271         u32 misc2 = le16_to_cpu(non_clock_info->usClassification);
2272         u16 vddc, vddci;
2273
2274         radeon_atombios_get_default_voltages(rdev, &vddc, &vddci);
2275
2276         rdev->pm.power_state[state_index].misc = misc;
2277         rdev->pm.power_state[state_index].misc2 = misc2;
2278         rdev->pm.power_state[state_index].pcie_lanes =
2279                 ((misc & ATOM_PPLIB_PCIE_LINK_WIDTH_MASK) >>
2280                  ATOM_PPLIB_PCIE_LINK_WIDTH_SHIFT) + 1;
2281         switch (misc2 & ATOM_PPLIB_CLASSIFICATION_UI_MASK) {
2282         case ATOM_PPLIB_CLASSIFICATION_UI_BATTERY:
2283                 rdev->pm.power_state[state_index].type =
2284                         POWER_STATE_TYPE_BATTERY;
2285                 break;
2286         case ATOM_PPLIB_CLASSIFICATION_UI_BALANCED:
2287                 rdev->pm.power_state[state_index].type =
2288                         POWER_STATE_TYPE_BALANCED;
2289                 break;
2290         case ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE:
2291                 rdev->pm.power_state[state_index].type =
2292                         POWER_STATE_TYPE_PERFORMANCE;
2293                 break;
2294         case ATOM_PPLIB_CLASSIFICATION_UI_NONE:
2295                 if (misc2 & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE)
2296                         rdev->pm.power_state[state_index].type =
2297                                 POWER_STATE_TYPE_PERFORMANCE;
2298                 break;
2299         }
2300         rdev->pm.power_state[state_index].flags = 0;
2301         if (misc & ATOM_PPLIB_SINGLE_DISPLAY_ONLY)
2302                 rdev->pm.power_state[state_index].flags |=
2303                         RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2304         if (misc2 & ATOM_PPLIB_CLASSIFICATION_BOOT) {
2305                 rdev->pm.power_state[state_index].type =
2306                         POWER_STATE_TYPE_DEFAULT;
2307                 rdev->pm.default_power_state_index = state_index;
2308                 rdev->pm.power_state[state_index].default_clock_mode =
2309                         &rdev->pm.power_state[state_index].clock_info[mode_index - 1];
2310                 if (ASIC_IS_DCE5(rdev) && !(rdev->flags & RADEON_IS_IGP)) {
2311                         /* NI chips post without MC ucode, so default clocks are strobe mode only */
2312                         rdev->pm.default_sclk = rdev->pm.power_state[state_index].clock_info[0].sclk;
2313                         rdev->pm.default_mclk = rdev->pm.power_state[state_index].clock_info[0].mclk;
2314                         rdev->pm.default_vddc = rdev->pm.power_state[state_index].clock_info[0].voltage.voltage;
2315                         rdev->pm.default_vddci = rdev->pm.power_state[state_index].clock_info[0].voltage.vddci;
2316                 } else {
2317                         /* patch the table values with the default slck/mclk from firmware info */
2318                         for (j = 0; j < mode_index; j++) {
2319                                 rdev->pm.power_state[state_index].clock_info[j].mclk =
2320                                         rdev->clock.default_mclk;
2321                                 rdev->pm.power_state[state_index].clock_info[j].sclk =
2322                                         rdev->clock.default_sclk;
2323                                 if (vddc)
2324                                         rdev->pm.power_state[state_index].clock_info[j].voltage.voltage =
2325                                                 vddc;
2326                         }
2327                 }
2328         }
2329 }
2330
2331 static bool radeon_atombios_parse_pplib_clock_info(struct radeon_device *rdev,
2332                                                    int state_index, int mode_index,
2333                                                    union pplib_clock_info *clock_info)
2334 {
2335         u32 sclk, mclk;
2336         u16 vddc;
2337
2338         if (rdev->flags & RADEON_IS_IGP) {
2339                 if (rdev->family >= CHIP_PALM) {
2340                         sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow);
2341                         sclk |= clock_info->sumo.ucEngineClockHigh << 16;
2342                         rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2343                 } else {
2344                         sclk = le16_to_cpu(clock_info->rs780.usLowEngineClockLow);
2345                         sclk |= clock_info->rs780.ucLowEngineClockHigh << 16;
2346                         rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2347                 }
2348         } else if (ASIC_IS_DCE6(rdev)) {
2349                 sclk = le16_to_cpu(clock_info->si.usEngineClockLow);
2350                 sclk |= clock_info->si.ucEngineClockHigh << 16;
2351                 mclk = le16_to_cpu(clock_info->si.usMemoryClockLow);
2352                 mclk |= clock_info->si.ucMemoryClockHigh << 16;
2353                 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2354                 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2355                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2356                         VOLTAGE_SW;
2357                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2358                         le16_to_cpu(clock_info->si.usVDDC);
2359                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.vddci =
2360                         le16_to_cpu(clock_info->si.usVDDCI);
2361         } else if (ASIC_IS_DCE4(rdev)) {
2362                 sclk = le16_to_cpu(clock_info->evergreen.usEngineClockLow);
2363                 sclk |= clock_info->evergreen.ucEngineClockHigh << 16;
2364                 mclk = le16_to_cpu(clock_info->evergreen.usMemoryClockLow);
2365                 mclk |= clock_info->evergreen.ucMemoryClockHigh << 16;
2366                 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2367                 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2368                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2369                         VOLTAGE_SW;
2370                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2371                         le16_to_cpu(clock_info->evergreen.usVDDC);
2372                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.vddci =
2373                         le16_to_cpu(clock_info->evergreen.usVDDCI);
2374         } else {
2375                 sclk = le16_to_cpu(clock_info->r600.usEngineClockLow);
2376                 sclk |= clock_info->r600.ucEngineClockHigh << 16;
2377                 mclk = le16_to_cpu(clock_info->r600.usMemoryClockLow);
2378                 mclk |= clock_info->r600.ucMemoryClockHigh << 16;
2379                 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2380                 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2381                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2382                         VOLTAGE_SW;
2383                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2384                         le16_to_cpu(clock_info->r600.usVDDC);
2385         }
2386
2387         /* patch up vddc if necessary */
2388         switch (rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage) {
2389         case ATOM_VIRTUAL_VOLTAGE_ID0:
2390         case ATOM_VIRTUAL_VOLTAGE_ID1:
2391         case ATOM_VIRTUAL_VOLTAGE_ID2:
2392         case ATOM_VIRTUAL_VOLTAGE_ID3:
2393                 if (radeon_atom_get_max_vddc(rdev, VOLTAGE_TYPE_VDDC,
2394                                              rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage,
2395                                              &vddc) == 0)
2396                         rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage = vddc;
2397                 break;
2398         default:
2399                 break;
2400         }
2401
2402         if (rdev->flags & RADEON_IS_IGP) {
2403                 /* skip invalid modes */
2404                 if (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0)
2405                         return false;
2406         } else {
2407                 /* skip invalid modes */
2408                 if ((rdev->pm.power_state[state_index].clock_info[mode_index].mclk == 0) ||
2409                     (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0))
2410                         return false;
2411         }
2412         return true;
2413 }
2414
2415 static int radeon_atombios_parse_power_table_4_5(struct radeon_device *rdev)
2416 {
2417         struct radeon_mode_info *mode_info = &rdev->mode_info;
2418         struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2419         union pplib_power_state *power_state;
2420         int i, j;
2421         int state_index = 0, mode_index = 0;
2422         union pplib_clock_info *clock_info;
2423         bool valid;
2424         union power_info *power_info;
2425         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2426         u16 data_offset;
2427         u8 frev, crev;
2428
2429         if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2430                                    &frev, &crev, &data_offset))
2431                 return state_index;
2432         power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2433
2434         radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2435         rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) *
2436                                        power_info->pplib.ucNumStates, GFP_KERNEL);
2437         if (!rdev->pm.power_state)
2438                 return state_index;
2439         /* first mode is usually default, followed by low to high */
2440         for (i = 0; i < power_info->pplib.ucNumStates; i++) {
2441                 mode_index = 0;
2442                 power_state = (union pplib_power_state *)
2443                         (mode_info->atom_context->bios + data_offset +
2444                          le16_to_cpu(power_info->pplib.usStateArrayOffset) +
2445                          i * power_info->pplib.ucStateEntrySize);
2446                 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2447                         (mode_info->atom_context->bios + data_offset +
2448                          le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset) +
2449                          (power_state->v1.ucNonClockStateIndex *
2450                           power_info->pplib.ucNonClockSize));
2451                 rdev->pm.power_state[i].clock_info = kzalloc(sizeof(struct radeon_pm_clock_info) *
2452                                                              ((power_info->pplib.ucStateEntrySize - 1) ?
2453                                                               (power_info->pplib.ucStateEntrySize - 1) : 1),
2454                                                              GFP_KERNEL);
2455                 if (!rdev->pm.power_state[i].clock_info)
2456                         return state_index;
2457                 if (power_info->pplib.ucStateEntrySize - 1) {
2458                         for (j = 0; j < (power_info->pplib.ucStateEntrySize - 1); j++) {
2459                                 clock_info = (union pplib_clock_info *)
2460                                         (mode_info->atom_context->bios + data_offset +
2461                                          le16_to_cpu(power_info->pplib.usClockInfoArrayOffset) +
2462                                          (power_state->v1.ucClockStateIndices[j] *
2463                                           power_info->pplib.ucClockInfoSize));
2464                                 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2465                                                                                state_index, mode_index,
2466                                                                                clock_info);
2467                                 if (valid)
2468                                         mode_index++;
2469                         }
2470                 } else {
2471                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2472                                 rdev->clock.default_mclk;
2473                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2474                                 rdev->clock.default_sclk;
2475                         mode_index++;
2476                 }
2477                 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2478                 if (mode_index) {
2479                         radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2480                                                                    non_clock_info);
2481                         state_index++;
2482                 }
2483         }
2484         /* if multiple clock modes, mark the lowest as no display */
2485         for (i = 0; i < state_index; i++) {
2486                 if (rdev->pm.power_state[i].num_clock_modes > 1)
2487                         rdev->pm.power_state[i].clock_info[0].flags |=
2488                                 RADEON_PM_MODE_NO_DISPLAY;
2489         }
2490         /* first mode is usually default */
2491         if (rdev->pm.default_power_state_index == -1) {
2492                 rdev->pm.power_state[0].type =
2493                         POWER_STATE_TYPE_DEFAULT;
2494                 rdev->pm.default_power_state_index = 0;
2495                 rdev->pm.power_state[0].default_clock_mode =
2496                         &rdev->pm.power_state[0].clock_info[0];
2497         }
2498         return state_index;
2499 }
2500
2501 static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
2502 {
2503         struct radeon_mode_info *mode_info = &rdev->mode_info;
2504         struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2505         union pplib_power_state *power_state;
2506         int i, j, non_clock_array_index, clock_array_index;
2507         int state_index = 0, mode_index = 0;
2508         union pplib_clock_info *clock_info;
2509         struct _StateArray *state_array;
2510         struct _ClockInfoArray *clock_info_array;
2511         struct _NonClockInfoArray *non_clock_info_array;
2512         bool valid;
2513         union power_info *power_info;
2514         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2515         u16 data_offset;
2516         u8 frev, crev;
2517
2518         if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2519                                    &frev, &crev, &data_offset))
2520                 return state_index;
2521         power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2522
2523         radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2524         state_array = (struct _StateArray *)
2525                 (mode_info->atom_context->bios + data_offset +
2526                  le16_to_cpu(power_info->pplib.usStateArrayOffset));
2527         clock_info_array = (struct _ClockInfoArray *)
2528                 (mode_info->atom_context->bios + data_offset +
2529                  le16_to_cpu(power_info->pplib.usClockInfoArrayOffset));
2530         non_clock_info_array = (struct _NonClockInfoArray *)
2531                 (mode_info->atom_context->bios + data_offset +
2532                  le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
2533         rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) *
2534                                        state_array->ucNumEntries, GFP_KERNEL);
2535         if (!rdev->pm.power_state)
2536                 return state_index;
2537         for (i = 0; i < state_array->ucNumEntries; i++) {
2538                 mode_index = 0;
2539                 power_state = (union pplib_power_state *)&state_array->states[i];
2540                 /* XXX this might be an inagua bug... */
2541                 non_clock_array_index = i; /* power_state->v2.nonClockInfoIndex */
2542                 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2543                         &non_clock_info_array->nonClockInfo[non_clock_array_index];
2544                 rdev->pm.power_state[i].clock_info = kzalloc(sizeof(struct radeon_pm_clock_info) *
2545                                                              (power_state->v2.ucNumDPMLevels ?
2546                                                               power_state->v2.ucNumDPMLevels : 1),
2547                                                              GFP_KERNEL);
2548                 if (!rdev->pm.power_state[i].clock_info)
2549                         return state_index;
2550                 if (power_state->v2.ucNumDPMLevels) {
2551                         for (j = 0; j < power_state->v2.ucNumDPMLevels; j++) {
2552                                 clock_array_index = power_state->v2.clockInfoIndex[j];
2553                                 /* XXX this might be an inagua bug... */
2554                                 if (clock_array_index >= clock_info_array->ucNumEntries)
2555                                         continue;
2556                                 clock_info = (union pplib_clock_info *)
2557                                         &clock_info_array->clockInfo[clock_array_index * clock_info_array->ucEntrySize];
2558                                 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2559                                                                                state_index, mode_index,
2560                                                                                clock_info);
2561                                 if (valid)
2562                                         mode_index++;
2563                         }
2564                 } else {
2565                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2566                                 rdev->clock.default_mclk;
2567                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2568                                 rdev->clock.default_sclk;
2569                         mode_index++;
2570                 }
2571                 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2572                 if (mode_index) {
2573                         radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2574                                                                    non_clock_info);
2575                         state_index++;
2576                 }
2577         }
2578         /* if multiple clock modes, mark the lowest as no display */
2579         for (i = 0; i < state_index; i++) {
2580                 if (rdev->pm.power_state[i].num_clock_modes > 1)
2581                         rdev->pm.power_state[i].clock_info[0].flags |=
2582                                 RADEON_PM_MODE_NO_DISPLAY;
2583         }
2584         /* first mode is usually default */
2585         if (rdev->pm.default_power_state_index == -1) {
2586                 rdev->pm.power_state[0].type =
2587                         POWER_STATE_TYPE_DEFAULT;
2588                 rdev->pm.default_power_state_index = 0;
2589                 rdev->pm.power_state[0].default_clock_mode =
2590                         &rdev->pm.power_state[0].clock_info[0];
2591         }
2592         return state_index;
2593 }
2594
2595 void radeon_atombios_get_power_modes(struct radeon_device *rdev)
2596 {
2597         struct radeon_mode_info *mode_info = &rdev->mode_info;
2598         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2599         u16 data_offset;
2600         u8 frev, crev;
2601         int state_index = 0;
2602
2603         rdev->pm.default_power_state_index = -1;
2604
2605         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2606                                    &frev, &crev, &data_offset)) {
2607                 switch (frev) {
2608                 case 1:
2609                 case 2:
2610                 case 3:
2611                         state_index = radeon_atombios_parse_power_table_1_3(rdev);
2612                         break;
2613                 case 4:
2614                 case 5:
2615                         state_index = radeon_atombios_parse_power_table_4_5(rdev);
2616                         break;
2617                 case 6:
2618                         state_index = radeon_atombios_parse_power_table_6(rdev);
2619                         break;
2620                 default:
2621                         break;
2622                 }
2623         } else {
2624                 rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state), GFP_KERNEL);
2625                 if (rdev->pm.power_state) {
2626                         rdev->pm.power_state[0].clock_info =
2627                                 kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL);
2628                         if (rdev->pm.power_state[0].clock_info) {
2629                                 /* add the default mode */
2630                                 rdev->pm.power_state[state_index].type =
2631                                         POWER_STATE_TYPE_DEFAULT;
2632                                 rdev->pm.power_state[state_index].num_clock_modes = 1;
2633                                 rdev->pm.power_state[state_index].clock_info[0].mclk = rdev->clock.default_mclk;
2634                                 rdev->pm.power_state[state_index].clock_info[0].sclk = rdev->clock.default_sclk;
2635                                 rdev->pm.power_state[state_index].default_clock_mode =
2636                                         &rdev->pm.power_state[state_index].clock_info[0];
2637                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2638                                 rdev->pm.power_state[state_index].pcie_lanes = 16;
2639                                 rdev->pm.default_power_state_index = state_index;
2640                                 rdev->pm.power_state[state_index].flags = 0;
2641                                 state_index++;
2642                         }
2643                 }
2644         }
2645
2646         rdev->pm.num_power_states = state_index;
2647
2648         rdev->pm.current_power_state_index = rdev->pm.default_power_state_index;
2649         rdev->pm.current_clock_mode_index = 0;
2650         if (rdev->pm.default_power_state_index >= 0)
2651                 rdev->pm.current_vddc =
2652                         rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.voltage;
2653         else
2654                 rdev->pm.current_vddc = 0;
2655 }
2656
2657 void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable)
2658 {
2659         DYNAMIC_CLOCK_GATING_PS_ALLOCATION args;
2660         int index = GetIndexIntoMasterTable(COMMAND, DynamicClockGating);
2661
2662         args.ucEnable = enable;
2663
2664         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2665 }
2666
2667 uint32_t radeon_atom_get_engine_clock(struct radeon_device *rdev)
2668 {
2669         GET_ENGINE_CLOCK_PS_ALLOCATION args;
2670         int index = GetIndexIntoMasterTable(COMMAND, GetEngineClock);
2671
2672         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2673         return le32_to_cpu(args.ulReturnEngineClock);
2674 }
2675
2676 uint32_t radeon_atom_get_memory_clock(struct radeon_device *rdev)
2677 {
2678         GET_MEMORY_CLOCK_PS_ALLOCATION args;
2679         int index = GetIndexIntoMasterTable(COMMAND, GetMemoryClock);
2680
2681         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2682         return le32_to_cpu(args.ulReturnMemoryClock);
2683 }
2684
2685 void radeon_atom_set_engine_clock(struct radeon_device *rdev,
2686                                   uint32_t eng_clock)
2687 {
2688         SET_ENGINE_CLOCK_PS_ALLOCATION args;
2689         int index = GetIndexIntoMasterTable(COMMAND, SetEngineClock);
2690
2691         args.ulTargetEngineClock = cpu_to_le32(eng_clock);      /* 10 khz */
2692
2693         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2694 }
2695
2696 void radeon_atom_set_memory_clock(struct radeon_device *rdev,
2697                                   uint32_t mem_clock)
2698 {
2699         SET_MEMORY_CLOCK_PS_ALLOCATION args;
2700         int index = GetIndexIntoMasterTable(COMMAND, SetMemoryClock);
2701
2702         if (rdev->flags & RADEON_IS_IGP)
2703                 return;
2704
2705         args.ulTargetMemoryClock = cpu_to_le32(mem_clock);      /* 10 khz */
2706
2707         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2708 }
2709
2710 union set_voltage {
2711         struct _SET_VOLTAGE_PS_ALLOCATION alloc;
2712         struct _SET_VOLTAGE_PARAMETERS v1;
2713         struct _SET_VOLTAGE_PARAMETERS_V2 v2;
2714         struct _SET_VOLTAGE_PARAMETERS_V1_3 v3;
2715 };
2716
2717 void radeon_atom_set_voltage(struct radeon_device *rdev, u16 voltage_level, u8 voltage_type)
2718 {
2719         union set_voltage args;
2720         int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
2721         u8 frev, crev, volt_index = voltage_level;
2722
2723         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2724                 return;
2725
2726         /* 0xff01 is a flag rather then an actual voltage */
2727         if (voltage_level == 0xff01)
2728                 return;
2729
2730         switch (crev) {
2731         case 1:
2732                 args.v1.ucVoltageType = voltage_type;
2733                 args.v1.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_ALL_SOURCE;
2734                 args.v1.ucVoltageIndex = volt_index;
2735                 break;
2736         case 2:
2737                 args.v2.ucVoltageType = voltage_type;
2738                 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_SET_VOLTAGE;
2739                 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
2740                 break;
2741         case 3:
2742                 args.v3.ucVoltageType = voltage_type;
2743                 args.v3.ucVoltageMode = ATOM_SET_VOLTAGE;
2744                 args.v3.usVoltageLevel = cpu_to_le16(voltage_level);
2745                 break;
2746         default:
2747                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
2748                 return;
2749         }
2750
2751         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2752 }
2753
2754 static int radeon_atom_get_max_vddc(struct radeon_device *rdev, u8 voltage_type,
2755                                     u16 voltage_id, u16 *voltage)
2756 {
2757         union set_voltage args;
2758         int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
2759         u8 frev, crev;
2760
2761         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2762                 return -EINVAL;
2763
2764         switch (crev) {
2765         case 1:
2766                 return -EINVAL;
2767         case 2:
2768                 args.v2.ucVoltageType = SET_VOLTAGE_GET_MAX_VOLTAGE;
2769                 args.v2.ucVoltageMode = 0;
2770                 args.v2.usVoltageLevel = 0;
2771
2772                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2773
2774                 *voltage = le16_to_cpu(args.v2.usVoltageLevel);
2775                 break;
2776         case 3:
2777                 args.v3.ucVoltageType = voltage_type;
2778                 args.v3.ucVoltageMode = ATOM_GET_VOLTAGE_LEVEL;
2779                 args.v3.usVoltageLevel = cpu_to_le16(voltage_id);
2780
2781                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2782
2783                 *voltage = le16_to_cpu(args.v3.usVoltageLevel);
2784                 break;
2785         default:
2786                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
2787                 return -EINVAL;
2788         }
2789
2790         return 0;
2791 }
2792
2793 void radeon_atom_initialize_bios_scratch_regs(struct drm_device *dev)
2794 {
2795         struct radeon_device *rdev = dev->dev_private;
2796         uint32_t bios_2_scratch, bios_6_scratch;
2797
2798         if (rdev->family >= CHIP_R600) {
2799                 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
2800                 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
2801         } else {
2802                 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
2803                 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
2804         }
2805
2806         /* let the bios control the backlight */
2807         bios_2_scratch &= ~ATOM_S2_VRI_BRIGHT_ENABLE;
2808
2809         /* tell the bios not to handle mode switching */
2810         bios_6_scratch |= ATOM_S6_ACC_BLOCK_DISPLAY_SWITCH;
2811
2812         if (rdev->family >= CHIP_R600) {
2813                 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
2814                 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
2815         } else {
2816                 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
2817                 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
2818         }
2819
2820 }
2821
2822 void radeon_save_bios_scratch_regs(struct radeon_device *rdev)
2823 {
2824         uint32_t scratch_reg;
2825         int i;
2826
2827         if (rdev->family >= CHIP_R600)
2828                 scratch_reg = R600_BIOS_0_SCRATCH;
2829         else
2830                 scratch_reg = RADEON_BIOS_0_SCRATCH;
2831
2832         for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
2833                 rdev->bios_scratch[i] = RREG32(scratch_reg + (i * 4));
2834 }
2835
2836 void radeon_restore_bios_scratch_regs(struct radeon_device *rdev)
2837 {
2838         uint32_t scratch_reg;
2839         int i;
2840
2841         if (rdev->family >= CHIP_R600)
2842                 scratch_reg = R600_BIOS_0_SCRATCH;
2843         else
2844                 scratch_reg = RADEON_BIOS_0_SCRATCH;
2845
2846         for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
2847                 WREG32(scratch_reg + (i * 4), rdev->bios_scratch[i]);
2848 }
2849
2850 void radeon_atom_output_lock(struct drm_encoder *encoder, bool lock)
2851 {
2852         struct drm_device *dev = encoder->dev;
2853         struct radeon_device *rdev = dev->dev_private;
2854         uint32_t bios_6_scratch;
2855
2856         if (rdev->family >= CHIP_R600)
2857                 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
2858         else
2859                 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
2860
2861         if (lock) {
2862                 bios_6_scratch |= ATOM_S6_CRITICAL_STATE;
2863                 bios_6_scratch &= ~ATOM_S6_ACC_MODE;
2864         } else {
2865                 bios_6_scratch &= ~ATOM_S6_CRITICAL_STATE;
2866                 bios_6_scratch |= ATOM_S6_ACC_MODE;
2867         }
2868
2869         if (rdev->family >= CHIP_R600)
2870                 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
2871         else
2872                 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
2873 }
2874
2875 /* at some point we may want to break this out into individual functions */
2876 void
2877 radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
2878                                        struct drm_encoder *encoder,
2879                                        bool connected)
2880 {
2881         struct drm_device *dev = connector->dev;
2882         struct radeon_device *rdev = dev->dev_private;
2883         struct radeon_connector *radeon_connector =
2884             to_radeon_connector(connector);
2885         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
2886         uint32_t bios_0_scratch, bios_3_scratch, bios_6_scratch;
2887
2888         if (rdev->family >= CHIP_R600) {
2889                 bios_0_scratch = RREG32(R600_BIOS_0_SCRATCH);
2890                 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
2891                 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
2892         } else {
2893                 bios_0_scratch = RREG32(RADEON_BIOS_0_SCRATCH);
2894                 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
2895                 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
2896         }
2897
2898         if ((radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) &&
2899             (radeon_connector->devices & ATOM_DEVICE_TV1_SUPPORT)) {
2900                 if (connected) {
2901                         DRM_DEBUG_KMS("TV1 connected\n");
2902                         bios_3_scratch |= ATOM_S3_TV1_ACTIVE;
2903                         bios_6_scratch |= ATOM_S6_ACC_REQ_TV1;
2904                 } else {
2905                         DRM_DEBUG_KMS("TV1 disconnected\n");
2906                         bios_0_scratch &= ~ATOM_S0_TV1_MASK;
2907                         bios_3_scratch &= ~ATOM_S3_TV1_ACTIVE;
2908                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_TV1;
2909                 }
2910         }
2911         if ((radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) &&
2912             (radeon_connector->devices & ATOM_DEVICE_CV_SUPPORT)) {
2913                 if (connected) {
2914                         DRM_DEBUG_KMS("CV connected\n");
2915                         bios_3_scratch |= ATOM_S3_CV_ACTIVE;
2916                         bios_6_scratch |= ATOM_S6_ACC_REQ_CV;
2917                 } else {
2918                         DRM_DEBUG_KMS("CV disconnected\n");
2919                         bios_0_scratch &= ~ATOM_S0_CV_MASK;
2920                         bios_3_scratch &= ~ATOM_S3_CV_ACTIVE;
2921                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_CV;
2922                 }
2923         }
2924         if ((radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) &&
2925             (radeon_connector->devices & ATOM_DEVICE_LCD1_SUPPORT)) {
2926                 if (connected) {
2927                         DRM_DEBUG_KMS("LCD1 connected\n");
2928                         bios_0_scratch |= ATOM_S0_LCD1;
2929                         bios_3_scratch |= ATOM_S3_LCD1_ACTIVE;
2930                         bios_6_scratch |= ATOM_S6_ACC_REQ_LCD1;
2931                 } else {
2932                         DRM_DEBUG_KMS("LCD1 disconnected\n");
2933                         bios_0_scratch &= ~ATOM_S0_LCD1;
2934                         bios_3_scratch &= ~ATOM_S3_LCD1_ACTIVE;
2935                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_LCD1;
2936                 }
2937         }
2938         if ((radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) &&
2939             (radeon_connector->devices & ATOM_DEVICE_CRT1_SUPPORT)) {
2940                 if (connected) {
2941                         DRM_DEBUG_KMS("CRT1 connected\n");
2942                         bios_0_scratch |= ATOM_S0_CRT1_COLOR;
2943                         bios_3_scratch |= ATOM_S3_CRT1_ACTIVE;
2944                         bios_6_scratch |= ATOM_S6_ACC_REQ_CRT1;
2945                 } else {
2946                         DRM_DEBUG_KMS("CRT1 disconnected\n");
2947                         bios_0_scratch &= ~ATOM_S0_CRT1_MASK;
2948                         bios_3_scratch &= ~ATOM_S3_CRT1_ACTIVE;
2949                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT1;
2950                 }
2951         }
2952         if ((radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) &&
2953             (radeon_connector->devices & ATOM_DEVICE_CRT2_SUPPORT)) {
2954                 if (connected) {
2955                         DRM_DEBUG_KMS("CRT2 connected\n");
2956                         bios_0_scratch |= ATOM_S0_CRT2_COLOR;
2957                         bios_3_scratch |= ATOM_S3_CRT2_ACTIVE;
2958                         bios_6_scratch |= ATOM_S6_ACC_REQ_CRT2;
2959                 } else {
2960                         DRM_DEBUG_KMS("CRT2 disconnected\n");
2961                         bios_0_scratch &= ~ATOM_S0_CRT2_MASK;
2962                         bios_3_scratch &= ~ATOM_S3_CRT2_ACTIVE;
2963                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT2;
2964                 }
2965         }
2966         if ((radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) &&
2967             (radeon_connector->devices & ATOM_DEVICE_DFP1_SUPPORT)) {
2968                 if (connected) {
2969                         DRM_DEBUG_KMS("DFP1 connected\n");
2970                         bios_0_scratch |= ATOM_S0_DFP1;
2971                         bios_3_scratch |= ATOM_S3_DFP1_ACTIVE;
2972                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP1;
2973                 } else {
2974                         DRM_DEBUG_KMS("DFP1 disconnected\n");
2975                         bios_0_scratch &= ~ATOM_S0_DFP1;
2976                         bios_3_scratch &= ~ATOM_S3_DFP1_ACTIVE;
2977                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP1;
2978                 }
2979         }
2980         if ((radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) &&
2981             (radeon_connector->devices & ATOM_DEVICE_DFP2_SUPPORT)) {
2982                 if (connected) {
2983                         DRM_DEBUG_KMS("DFP2 connected\n");
2984                         bios_0_scratch |= ATOM_S0_DFP2;
2985                         bios_3_scratch |= ATOM_S3_DFP2_ACTIVE;
2986                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP2;
2987                 } else {
2988                         DRM_DEBUG_KMS("DFP2 disconnected\n");
2989                         bios_0_scratch &= ~ATOM_S0_DFP2;
2990                         bios_3_scratch &= ~ATOM_S3_DFP2_ACTIVE;
2991                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP2;
2992                 }
2993         }
2994         if ((radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) &&
2995             (radeon_connector->devices & ATOM_DEVICE_DFP3_SUPPORT)) {
2996                 if (connected) {
2997                         DRM_DEBUG_KMS("DFP3 connected\n");
2998                         bios_0_scratch |= ATOM_S0_DFP3;
2999                         bios_3_scratch |= ATOM_S3_DFP3_ACTIVE;
3000                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP3;
3001                 } else {
3002                         DRM_DEBUG_KMS("DFP3 disconnected\n");
3003                         bios_0_scratch &= ~ATOM_S0_DFP3;
3004                         bios_3_scratch &= ~ATOM_S3_DFP3_ACTIVE;
3005                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP3;
3006                 }
3007         }
3008         if ((radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) &&
3009             (radeon_connector->devices & ATOM_DEVICE_DFP4_SUPPORT)) {
3010                 if (connected) {
3011                         DRM_DEBUG_KMS("DFP4 connected\n");
3012                         bios_0_scratch |= ATOM_S0_DFP4;
3013                         bios_3_scratch |= ATOM_S3_DFP4_ACTIVE;
3014                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP4;
3015                 } else {
3016                         DRM_DEBUG_KMS("DFP4 disconnected\n");
3017                         bios_0_scratch &= ~ATOM_S0_DFP4;
3018                         bios_3_scratch &= ~ATOM_S3_DFP4_ACTIVE;
3019                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP4;
3020                 }
3021         }
3022         if ((radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) &&
3023             (radeon_connector->devices & ATOM_DEVICE_DFP5_SUPPORT)) {
3024                 if (connected) {
3025                         DRM_DEBUG_KMS("DFP5 connected\n");
3026                         bios_0_scratch |= ATOM_S0_DFP5;
3027                         bios_3_scratch |= ATOM_S3_DFP5_ACTIVE;
3028                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP5;
3029                 } else {
3030                         DRM_DEBUG_KMS("DFP5 disconnected\n");
3031                         bios_0_scratch &= ~ATOM_S0_DFP5;
3032                         bios_3_scratch &= ~ATOM_S3_DFP5_ACTIVE;
3033                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP5;
3034                 }
3035         }
3036         if ((radeon_encoder->devices & ATOM_DEVICE_DFP6_SUPPORT) &&
3037             (radeon_connector->devices & ATOM_DEVICE_DFP6_SUPPORT)) {
3038                 if (connected) {
3039                         DRM_DEBUG_KMS("DFP6 connected\n");
3040                         bios_0_scratch |= ATOM_S0_DFP6;
3041                         bios_3_scratch |= ATOM_S3_DFP6_ACTIVE;
3042                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP6;
3043                 } else {
3044                         DRM_DEBUG_KMS("DFP6 disconnected\n");
3045                         bios_0_scratch &= ~ATOM_S0_DFP6;
3046                         bios_3_scratch &= ~ATOM_S3_DFP6_ACTIVE;
3047                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP6;
3048                 }
3049         }
3050
3051         if (rdev->family >= CHIP_R600) {
3052                 WREG32(R600_BIOS_0_SCRATCH, bios_0_scratch);
3053                 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
3054                 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
3055         } else {
3056                 WREG32(RADEON_BIOS_0_SCRATCH, bios_0_scratch);
3057                 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
3058                 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
3059         }
3060 }
3061
3062 void
3063 radeon_atombios_encoder_crtc_scratch_regs(struct drm_encoder *encoder, int crtc)
3064 {
3065         struct drm_device *dev = encoder->dev;
3066         struct radeon_device *rdev = dev->dev_private;
3067         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
3068         uint32_t bios_3_scratch;
3069
3070         if (ASIC_IS_DCE4(rdev))
3071                 return;
3072
3073         if (rdev->family >= CHIP_R600)
3074                 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
3075         else
3076                 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
3077
3078         if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
3079                 bios_3_scratch &= ~ATOM_S3_TV1_CRTC_ACTIVE;
3080                 bios_3_scratch |= (crtc << 18);
3081         }
3082         if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
3083                 bios_3_scratch &= ~ATOM_S3_CV_CRTC_ACTIVE;
3084                 bios_3_scratch |= (crtc << 24);
3085         }
3086         if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
3087                 bios_3_scratch &= ~ATOM_S3_CRT1_CRTC_ACTIVE;
3088                 bios_3_scratch |= (crtc << 16);
3089         }
3090         if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
3091                 bios_3_scratch &= ~ATOM_S3_CRT2_CRTC_ACTIVE;
3092                 bios_3_scratch |= (crtc << 20);
3093         }
3094         if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
3095                 bios_3_scratch &= ~ATOM_S3_LCD1_CRTC_ACTIVE;
3096                 bios_3_scratch |= (crtc << 17);
3097         }
3098         if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
3099                 bios_3_scratch &= ~ATOM_S3_DFP1_CRTC_ACTIVE;
3100                 bios_3_scratch |= (crtc << 19);
3101         }
3102         if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
3103                 bios_3_scratch &= ~ATOM_S3_DFP2_CRTC_ACTIVE;
3104                 bios_3_scratch |= (crtc << 23);
3105         }
3106         if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
3107                 bios_3_scratch &= ~ATOM_S3_DFP3_CRTC_ACTIVE;
3108                 bios_3_scratch |= (crtc << 25);
3109         }
3110
3111         if (rdev->family >= CHIP_R600)
3112                 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
3113         else
3114                 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
3115 }
3116
3117 void
3118 radeon_atombios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on)
3119 {
3120         struct drm_device *dev = encoder->dev;
3121         struct radeon_device *rdev = dev->dev_private;
3122         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
3123         uint32_t bios_2_scratch;
3124
3125         if (ASIC_IS_DCE4(rdev))
3126                 return;
3127
3128         if (rdev->family >= CHIP_R600)
3129                 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
3130         else
3131                 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
3132
3133         if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
3134                 if (on)
3135                         bios_2_scratch &= ~ATOM_S2_TV1_DPMS_STATE;
3136                 else
3137                         bios_2_scratch |= ATOM_S2_TV1_DPMS_STATE;
3138         }
3139         if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
3140                 if (on)
3141                         bios_2_scratch &= ~ATOM_S2_CV_DPMS_STATE;
3142                 else
3143                         bios_2_scratch |= ATOM_S2_CV_DPMS_STATE;
3144         }
3145         if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
3146                 if (on)
3147                         bios_2_scratch &= ~ATOM_S2_CRT1_DPMS_STATE;
3148                 else
3149                         bios_2_scratch |= ATOM_S2_CRT1_DPMS_STATE;
3150         }
3151         if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
3152                 if (on)
3153                         bios_2_scratch &= ~ATOM_S2_CRT2_DPMS_STATE;
3154                 else
3155                         bios_2_scratch |= ATOM_S2_CRT2_DPMS_STATE;
3156         }
3157         if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
3158                 if (on)
3159                         bios_2_scratch &= ~ATOM_S2_LCD1_DPMS_STATE;
3160                 else
3161                         bios_2_scratch |= ATOM_S2_LCD1_DPMS_STATE;
3162         }
3163         if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
3164                 if (on)
3165                         bios_2_scratch &= ~ATOM_S2_DFP1_DPMS_STATE;
3166                 else
3167                         bios_2_scratch |= ATOM_S2_DFP1_DPMS_STATE;
3168         }
3169         if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
3170                 if (on)
3171                         bios_2_scratch &= ~ATOM_S2_DFP2_DPMS_STATE;
3172                 else
3173                         bios_2_scratch |= ATOM_S2_DFP2_DPMS_STATE;
3174         }
3175         if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
3176                 if (on)
3177                         bios_2_scratch &= ~ATOM_S2_DFP3_DPMS_STATE;
3178                 else
3179                         bios_2_scratch |= ATOM_S2_DFP3_DPMS_STATE;
3180         }
3181         if (radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) {
3182                 if (on)
3183                         bios_2_scratch &= ~ATOM_S2_DFP4_DPMS_STATE;
3184                 else
3185                         bios_2_scratch |= ATOM_S2_DFP4_DPMS_STATE;
3186         }
3187         if (radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) {
3188                 if (on)
3189                         bios_2_scratch &= ~ATOM_S2_DFP5_DPMS_STATE;
3190                 else
3191                         bios_2_scratch |= ATOM_S2_DFP5_DPMS_STATE;
3192         }
3193
3194         if (rdev->family >= CHIP_R600)
3195                 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
3196         else
3197                 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
3198 }