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 extern void
  34 radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_enum,
  35                         uint32_t supported_device, u16 caps);
  36
  37 /* from radeon_legacy_encoder.c */
  38 extern void
  39 radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_enum,
  40                           uint32_t supported_device);
  41
  42 union atom_supported_devices {
  43         struct _ATOM_SUPPORTED_DEVICES_INFO info;
  44         struct _ATOM_SUPPORTED_DEVICES_INFO_2 info_2;
  45         struct _ATOM_SUPPORTED_DEVICES_INFO_2d1 info_2d1;
  46 };
  47
  48 static void radeon_lookup_i2c_gpio_quirks(struct radeon_device *rdev,
  49                                           ATOM_GPIO_I2C_ASSIGMENT *gpio,
  50                                           u8 index)
  51 {
  52         /* r4xx mask is technically not used by the hw, so patch in the legacy mask bits */
  53         if ((rdev->family == CHIP_R420) ||
  54             (rdev->family == CHIP_R423) ||
  55             (rdev->family == CHIP_RV410)) {
  56                 if ((le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x0018) ||
  57                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x0019) ||
  58                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x001a)) {
  59                         gpio->ucClkMaskShift = 0x19;
  60                         gpio->ucDataMaskShift = 0x18;
  61                 }
  62         }
  63
  64         /* some evergreen boards have bad data for this entry */
  65         if (ASIC_IS_DCE4(rdev)) {
  66                 if ((index == 7) &&
  67                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1936) &&
  68                     (gpio->sucI2cId.ucAccess == 0)) {
  69                         gpio->sucI2cId.ucAccess = 0x97;
  70                         gpio->ucDataMaskShift = 8;
  71                         gpio->ucDataEnShift = 8;
  72                         gpio->ucDataY_Shift = 8;
  73                         gpio->ucDataA_Shift = 8;
  74                 }
  75         }
  76
  77         /* some DCE3 boards have bad data for this entry */
  78         if (ASIC_IS_DCE3(rdev)) {
  79                 if ((index == 4) &&
  80                     (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1fda) &&
  81                     (gpio->sucI2cId.ucAccess == 0x94))
  82                         gpio->sucI2cId.ucAccess = 0x14;
  83         }
  84 }
  85
  86 static struct radeon_i2c_bus_rec radeon_get_bus_rec_for_i2c_gpio(ATOM_GPIO_I2C_ASSIGMENT *gpio)
  87 {
  88         struct radeon_i2c_bus_rec i2c;
  89
  90         memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
  91
  92         i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
  93         i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
  94         i2c.en_clk_reg = le16_to_cpu(gpio->usClkEnRegisterIndex) * 4;
  95         i2c.en_data_reg = le16_to_cpu(gpio->usDataEnRegisterIndex) * 4;
  96         i2c.y_clk_reg = le16_to_cpu(gpio->usClkY_RegisterIndex) * 4;
  97         i2c.y_data_reg = le16_to_cpu(gpio->usDataY_RegisterIndex) * 4;
  98         i2c.a_clk_reg = le16_to_cpu(gpio->usClkA_RegisterIndex) * 4;
  99         i2c.a_data_reg = le16_to_cpu(gpio->usDataA_RegisterIndex) * 4;
 100         i2c.mask_clk_mask = (1 << gpio->ucClkMaskShift);
 101         i2c.mask_data_mask = (1 << gpio->ucDataMaskShift);
 102         i2c.en_clk_mask = (1 << gpio->ucClkEnShift);
 103         i2c.en_data_mask = (1 << gpio->ucDataEnShift);
 104         i2c.y_clk_mask = (1 << gpio->ucClkY_Shift);
 105         i2c.y_data_mask = (1 << gpio->ucDataY_Shift);
 106         i2c.a_clk_mask = (1 << gpio->ucClkA_Shift);
 107         i2c.a_data_mask = (1 << gpio->ucDataA_Shift);
 108
 109         if (gpio->sucI2cId.sbfAccess.bfHW_Capable)
 110                 i2c.hw_capable = true;
 111         else
 112                 i2c.hw_capable = false;
 113
 114         if (gpio->sucI2cId.ucAccess == 0xa0)
 115                 i2c.mm_i2c = true;
 116         else
 117                 i2c.mm_i2c = false;
 118
 119         i2c.i2c_id = gpio->sucI2cId.ucAccess;
 120
 121         if (i2c.mask_clk_reg)
 122                 i2c.valid = true;
 123         else
 124                 i2c.valid = false;
 125
 126         return i2c;
 127 }
 128
 129 static struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_device *rdev,
 130                                                                uint8_t id)
 131 {
 132         struct atom_context *ctx = rdev->mode_info.atom_context;
 133         ATOM_GPIO_I2C_ASSIGMENT *gpio;
 134         struct radeon_i2c_bus_rec i2c;
 135         int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
 136         struct _ATOM_GPIO_I2C_INFO *i2c_info;
 137         uint16_t data_offset, size;
 138         int i, num_indices;
 139
 140         memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
 141         i2c.valid = false;
 142
 143         if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
 144                 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
 145
 146                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
 147                         sizeof(ATOM_GPIO_I2C_ASSIGMENT);
 148
 149                 gpio = &i2c_info->asGPIO_Info[0];
 150                 for (i = 0; i < num_indices; i++) {
 151
 152                         radeon_lookup_i2c_gpio_quirks(rdev, gpio, i);
 153
 154                         if (gpio->sucI2cId.ucAccess == id) {
 155                                 i2c = radeon_get_bus_rec_for_i2c_gpio(gpio);
 156                                 break;
 157                         }
 158                         gpio = (ATOM_GPIO_I2C_ASSIGMENT *)
 159                                 ((u8 *)gpio + sizeof(ATOM_GPIO_I2C_ASSIGMENT));
 160                 }
 161         }
 162
 163         return i2c;
 164 }
 165
 166 void radeon_atombios_i2c_init(struct radeon_device *rdev)
 167 {
 168         struct atom_context *ctx = rdev->mode_info.atom_context;
 169         ATOM_GPIO_I2C_ASSIGMENT *gpio;
 170         struct radeon_i2c_bus_rec i2c;
 171         int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
 172         struct _ATOM_GPIO_I2C_INFO *i2c_info;
 173         uint16_t data_offset, size;
 174         int i, num_indices;
 175         char stmp[32];
 176
 177         if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
 178                 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
 179
 180                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
 181                         sizeof(ATOM_GPIO_I2C_ASSIGMENT);
 182
 183                 gpio = &i2c_info->asGPIO_Info[0];
 184                 for (i = 0; i < num_indices; i++) {
 185                         radeon_lookup_i2c_gpio_quirks(rdev, gpio, i);
 186
 187                         i2c = radeon_get_bus_rec_for_i2c_gpio(gpio);
 188
 189                         if (i2c.valid) {
 190                                 sprintf(stmp, "0x%x", i2c.i2c_id);
 191                                 rdev->i2c_bus[i] = radeon_i2c_create(rdev->ddev, &i2c, stmp);
 192                         }
 193                         gpio = (ATOM_GPIO_I2C_ASSIGMENT *)
 194                                 ((u8 *)gpio + sizeof(ATOM_GPIO_I2C_ASSIGMENT));
 195                 }
 196         }
 197 }
 198
 199 struct radeon_gpio_rec radeon_atombios_lookup_gpio(struct radeon_device *rdev,
 200                                                    u8 id)
 201 {
 202         struct atom_context *ctx = rdev->mode_info.atom_context;
 203         struct radeon_gpio_rec gpio;
 204         int index = GetIndexIntoMasterTable(DATA, GPIO_Pin_LUT);
 205         struct _ATOM_GPIO_PIN_LUT *gpio_info;
 206         ATOM_GPIO_PIN_ASSIGNMENT *pin;
 207         u16 data_offset, size;
 208         int i, num_indices;
 209
 210         memset(&gpio, 0, sizeof(struct radeon_gpio_rec));
 211         gpio.valid = false;
 212
 213         if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
 214                 gpio_info = (struct _ATOM_GPIO_PIN_LUT *)(ctx->bios + data_offset);
 215
 216                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
 217                         sizeof(ATOM_GPIO_PIN_ASSIGNMENT);
 218
 219                 pin = gpio_info->asGPIO_Pin;
 220                 for (i = 0; i < num_indices; i++) {
 221                         if (id == pin->ucGPIO_ID) {
 222                                 gpio.id = pin->ucGPIO_ID;
 223                                 gpio.reg = le16_to_cpu(pin->usGpioPin_AIndex) * 4;
 224                                 gpio.shift = pin->ucGpioPinBitShift;
 225                                 gpio.mask = (1 << pin->ucGpioPinBitShift);
 226                                 gpio.valid = true;
 227                                 break;
 228                         }
 229                         pin = (ATOM_GPIO_PIN_ASSIGNMENT *)
 230                                 ((u8 *)pin + sizeof(ATOM_GPIO_PIN_ASSIGNMENT));
 231                 }
 232         }
 233
 234         return gpio;
 235 }
 236
 237 static struct radeon_hpd radeon_atom_get_hpd_info_from_gpio(struct radeon_device *rdev,
 238                                                             struct radeon_gpio_rec *gpio)
 239 {
 240         struct radeon_hpd hpd;
 241         u32 reg;
 242
 243         memset(&hpd, 0, sizeof(struct radeon_hpd));
 244
 245         if (ASIC_IS_DCE6(rdev))
 246                 reg = SI_DC_GPIO_HPD_A;
 247         else if (ASIC_IS_DCE4(rdev))
 248                 reg = EVERGREEN_DC_GPIO_HPD_A;
 249         else
 250                 reg = AVIVO_DC_GPIO_HPD_A;
 251
 252         hpd.gpio = *gpio;
 253         if (gpio->reg == reg) {
 254                 switch(gpio->mask) {
 255                 case (1 << 0):
 256                         hpd.hpd = RADEON_HPD_1;
 257                         break;
 258                 case (1 << 8):
 259                         hpd.hpd = RADEON_HPD_2;
 260                         break;
 261                 case (1 << 16):
 262                         hpd.hpd = RADEON_HPD_3;
 263                         break;
 264                 case (1 << 24):
 265                         hpd.hpd = RADEON_HPD_4;
 266                         break;
 267                 case (1 << 26):
 268                         hpd.hpd = RADEON_HPD_5;
 269                         break;
 270                 case (1 << 28):
 271                         hpd.hpd = RADEON_HPD_6;
 272                         break;
 273                 default:
 274                         hpd.hpd = RADEON_HPD_NONE;
 275                         break;
 276                 }
 277         } else
 278                 hpd.hpd = RADEON_HPD_NONE;
 279         return hpd;
 280 }
 281
 282 static bool radeon_atom_apply_quirks(struct drm_device *dev,
 283                                      uint32_t supported_device,
 284                                      int *connector_type,
 285                                      struct radeon_i2c_bus_rec *i2c_bus,
 286                                      uint16_t *line_mux,
 287                                      struct radeon_hpd *hpd)
 288 {
 289
 290         /* Asus M2A-VM HDMI board lists the DVI port as HDMI */
 291         if ((dev->pdev->device == 0x791e) &&
 292             (dev->pdev->subsystem_vendor == 0x1043) &&
 293             (dev->pdev->subsystem_device == 0x826d)) {
 294                 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
 295                     (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
 296                         *connector_type = DRM_MODE_CONNECTOR_DVID;
 297         }
 298
 299         /* Asrock RS600 board lists the DVI port as HDMI */
 300         if ((dev->pdev->device == 0x7941) &&
 301             (dev->pdev->subsystem_vendor == 0x1849) &&
 302             (dev->pdev->subsystem_device == 0x7941)) {
 303                 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
 304                     (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
 305                         *connector_type = DRM_MODE_CONNECTOR_DVID;
 306         }
 307
 308         /* MSI K9A2GM V2/V3 board has no HDMI or DVI */
 309         if ((dev->pdev->device == 0x796e) &&
 310             (dev->pdev->subsystem_vendor == 0x1462) &&
 311             (dev->pdev->subsystem_device == 0x7302)) {
 312                 if ((supported_device == ATOM_DEVICE_DFP2_SUPPORT) ||
 313                     (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
 314                         return false;
 315         }
 316
 317         /* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */
 318         if ((dev->pdev->device == 0x7941) &&
 319             (dev->pdev->subsystem_vendor == 0x147b) &&
 320             (dev->pdev->subsystem_device == 0x2412)) {
 321                 if (*connector_type == DRM_MODE_CONNECTOR_DVII)
 322                         return false;
 323         }
 324
 325         /* Falcon NW laptop lists vga ddc line for LVDS */
 326         if ((dev->pdev->device == 0x5653) &&
 327             (dev->pdev->subsystem_vendor == 0x1462) &&
 328             (dev->pdev->subsystem_device == 0x0291)) {
 329                 if (*connector_type == DRM_MODE_CONNECTOR_LVDS) {
 330                         i2c_bus->valid = false;
 331                         *line_mux = 53;
 332                 }
 333         }
 334
 335         /* HIS X1300 is DVI+VGA, not DVI+DVI */
 336         if ((dev->pdev->device == 0x7146) &&
 337             (dev->pdev->subsystem_vendor == 0x17af) &&
 338             (dev->pdev->subsystem_device == 0x2058)) {
 339                 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
 340                         return false;
 341         }
 342
 343         /* Gigabyte X1300 is DVI+VGA, not DVI+DVI */
 344         if ((dev->pdev->device == 0x7142) &&
 345             (dev->pdev->subsystem_vendor == 0x1458) &&
 346             (dev->pdev->subsystem_device == 0x2134)) {
 347                 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
 348                         return false;
 349         }
 350
 351
 352         /* Funky macbooks */
 353         if ((dev->pdev->device == 0x71C5) &&
 354             (dev->pdev->subsystem_vendor == 0x106b) &&
 355             (dev->pdev->subsystem_device == 0x0080)) {
 356                 if ((supported_device == ATOM_DEVICE_CRT1_SUPPORT) ||
 357                     (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
 358                         return false;
 359                 if (supported_device == ATOM_DEVICE_CRT2_SUPPORT)
 360                         *line_mux = 0x90;
 361         }
 362
 363         /* mac rv630, rv730, others */
 364         if ((supported_device == ATOM_DEVICE_TV1_SUPPORT) &&
 365             (*connector_type == DRM_MODE_CONNECTOR_DVII)) {
 366                 *connector_type = DRM_MODE_CONNECTOR_9PinDIN;
 367                 *line_mux = CONNECTOR_7PIN_DIN_ENUM_ID1;
 368         }
 369
 370         /* ASUS HD 3600 XT board lists the DVI port as HDMI */
 371         if ((dev->pdev->device == 0x9598) &&
 372             (dev->pdev->subsystem_vendor == 0x1043) &&
 373             (dev->pdev->subsystem_device == 0x01da)) {
 374                 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 375                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 376                 }
 377         }
 378
 379         /* ASUS HD 3600 board lists the DVI port as HDMI */
 380         if ((dev->pdev->device == 0x9598) &&
 381             (dev->pdev->subsystem_vendor == 0x1043) &&
 382             (dev->pdev->subsystem_device == 0x01e4)) {
 383                 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 384                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 385                 }
 386         }
 387
 388         /* ASUS HD 3450 board lists the DVI port as HDMI */
 389         if ((dev->pdev->device == 0x95C5) &&
 390             (dev->pdev->subsystem_vendor == 0x1043) &&
 391             (dev->pdev->subsystem_device == 0x01e2)) {
 392                 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 393                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 394                 }
 395         }
 396
 397         /* some BIOSes seem to report DAC on HDMI - usually this is a board with
 398          * HDMI + VGA reporting as HDMI
 399          */
 400         if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
 401                 if (supported_device & (ATOM_DEVICE_CRT_SUPPORT)) {
 402                         *connector_type = DRM_MODE_CONNECTOR_VGA;
 403                         *line_mux = 0;
 404                 }
 405         }
 406
 407         /* Acer laptop (Acer TravelMate 5730/5730G) has an HDMI port
 408          * on the laptop and a DVI port on the docking station and
 409          * both share the same encoder, hpd pin, and ddc line.
 410          * So while the bios table is technically correct,
 411          * we drop the DVI port here since xrandr has no concept of
 412          * encoders and will try and drive both connectors
 413          * with different crtcs which isn't possible on the hardware
 414          * side and leaves no crtcs for LVDS or VGA.
 415          */
 416         if (((dev->pdev->device == 0x95c4) || (dev->pdev->device == 0x9591)) &&
 417             (dev->pdev->subsystem_vendor == 0x1025) &&
 418             (dev->pdev->subsystem_device == 0x013c)) {
 419                 if ((*connector_type == DRM_MODE_CONNECTOR_DVII) &&
 420                     (supported_device == ATOM_DEVICE_DFP1_SUPPORT)) {
 421                         /* actually it's a DVI-D port not DVI-I */
 422                         *connector_type = DRM_MODE_CONNECTOR_DVID;
 423                         return false;
 424                 }
 425         }
 426
 427         /* XFX Pine Group device rv730 reports no VGA DDC lines
 428          * even though they are wired up to record 0x93
 429          */
 430         if ((dev->pdev->device == 0x9498) &&
 431             (dev->pdev->subsystem_vendor == 0x1682) &&
 432             (dev->pdev->subsystem_device == 0x2452) &&
 433             (i2c_bus->valid == false) &&
 434             !(supported_device & (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT))) {
 435                 struct radeon_device *rdev = dev->dev_private;
 436                 *i2c_bus = radeon_lookup_i2c_gpio(rdev, 0x93);
 437         }
 438
 439         /* Fujitsu D3003-S2 board lists DVI-I as DVI-D and VGA */
 440         if (((dev->pdev->device == 0x9802) || (dev->pdev->device == 0x9806)) &&
 441             (dev->pdev->subsystem_vendor == 0x1734) &&
 442             (dev->pdev->subsystem_device == 0x11bd)) {
 443                 if (*connector_type == DRM_MODE_CONNECTOR_VGA) {
 444                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 445                         *line_mux = 0x3103;
 446                 } else if (*connector_type == DRM_MODE_CONNECTOR_DVID) {
 447                         *connector_type = DRM_MODE_CONNECTOR_DVII;
 448                 }
 449         }
 450
 451         /* Fujitsu D3003-S2 board lists DVI-I as DVI-I and VGA */
 452         if ((dev->pdev->device == 0x9805) &&
 453             (dev->pdev->subsystem_vendor == 0x1734) &&
 454             (dev->pdev->subsystem_device == 0x11bd)) {
 455                 if (*connector_type == DRM_MODE_CONNECTOR_VGA)
 456                         return false;
 457         }
 458
 459         return true;
 460 }
 461
 462 static const int supported_devices_connector_convert[] = {
 463         DRM_MODE_CONNECTOR_Unknown,
 464         DRM_MODE_CONNECTOR_VGA,
 465         DRM_MODE_CONNECTOR_DVII,
 466         DRM_MODE_CONNECTOR_DVID,
 467         DRM_MODE_CONNECTOR_DVIA,
 468         DRM_MODE_CONNECTOR_SVIDEO,
 469         DRM_MODE_CONNECTOR_Composite,
 470         DRM_MODE_CONNECTOR_LVDS,
 471         DRM_MODE_CONNECTOR_Unknown,
 472         DRM_MODE_CONNECTOR_Unknown,
 473         DRM_MODE_CONNECTOR_HDMIA,
 474         DRM_MODE_CONNECTOR_HDMIB,
 475         DRM_MODE_CONNECTOR_Unknown,
 476         DRM_MODE_CONNECTOR_Unknown,
 477         DRM_MODE_CONNECTOR_9PinDIN,
 478         DRM_MODE_CONNECTOR_DisplayPort
 479 };
 480
 481 static const uint16_t supported_devices_connector_object_id_convert[] = {
 482         CONNECTOR_OBJECT_ID_NONE,
 483         CONNECTOR_OBJECT_ID_VGA,
 484         CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I, /* not all boards support DL */
 485         CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D, /* not all boards support DL */
 486         CONNECTOR_OBJECT_ID_VGA, /* technically DVI-A */
 487         CONNECTOR_OBJECT_ID_COMPOSITE,
 488         CONNECTOR_OBJECT_ID_SVIDEO,
 489         CONNECTOR_OBJECT_ID_LVDS,
 490         CONNECTOR_OBJECT_ID_9PIN_DIN,
 491         CONNECTOR_OBJECT_ID_9PIN_DIN,
 492         CONNECTOR_OBJECT_ID_DISPLAYPORT,
 493         CONNECTOR_OBJECT_ID_HDMI_TYPE_A,
 494         CONNECTOR_OBJECT_ID_HDMI_TYPE_B,
 495         CONNECTOR_OBJECT_ID_SVIDEO
 496 };
 497
 498 static const int object_connector_convert[] = {
 499         DRM_MODE_CONNECTOR_Unknown,
 500         DRM_MODE_CONNECTOR_DVII,
 501         DRM_MODE_CONNECTOR_DVII,
 502         DRM_MODE_CONNECTOR_DVID,
 503         DRM_MODE_CONNECTOR_DVID,
 504         DRM_MODE_CONNECTOR_VGA,
 505         DRM_MODE_CONNECTOR_Composite,
 506         DRM_MODE_CONNECTOR_SVIDEO,
 507         DRM_MODE_CONNECTOR_Unknown,
 508         DRM_MODE_CONNECTOR_Unknown,
 509         DRM_MODE_CONNECTOR_9PinDIN,
 510         DRM_MODE_CONNECTOR_Unknown,
 511         DRM_MODE_CONNECTOR_HDMIA,
 512         DRM_MODE_CONNECTOR_HDMIB,
 513         DRM_MODE_CONNECTOR_LVDS,
 514         DRM_MODE_CONNECTOR_9PinDIN,
 515         DRM_MODE_CONNECTOR_Unknown,
 516         DRM_MODE_CONNECTOR_Unknown,
 517         DRM_MODE_CONNECTOR_Unknown,
 518         DRM_MODE_CONNECTOR_DisplayPort,
 519         DRM_MODE_CONNECTOR_eDP,
 520         DRM_MODE_CONNECTOR_Unknown
 521 };
 522
 523 bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
 524 {
 525         struct radeon_device *rdev = dev->dev_private;
 526         struct radeon_mode_info *mode_info = &rdev->mode_info;
 527         struct atom_context *ctx = mode_info->atom_context;
 528         int index = GetIndexIntoMasterTable(DATA, Object_Header);
 529         u16 size, data_offset;
 530         u8 frev, crev;
 531         ATOM_CONNECTOR_OBJECT_TABLE *con_obj;
 532         ATOM_ENCODER_OBJECT_TABLE *enc_obj;
 533         ATOM_OBJECT_TABLE *router_obj;
 534         ATOM_DISPLAY_OBJECT_PATH_TABLE *path_obj;
 535         ATOM_OBJECT_HEADER *obj_header;
 536         int i, j, k, path_size, device_support;
 537         int connector_type;
 538         u16 igp_lane_info, conn_id, connector_object_id;
 539         struct radeon_i2c_bus_rec ddc_bus;
 540         struct radeon_router router;
 541         struct radeon_gpio_rec gpio;
 542         struct radeon_hpd hpd;
 543
 544         if (!atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset))
 545                 return false;
 546
 547         if (crev < 2)
 548                 return false;
 549
 550         obj_header = (ATOM_OBJECT_HEADER *) (ctx->bios + data_offset);
 551         path_obj = (ATOM_DISPLAY_OBJECT_PATH_TABLE *)
 552             (ctx->bios + data_offset +
 553              le16_to_cpu(obj_header->usDisplayPathTableOffset));
 554         con_obj = (ATOM_CONNECTOR_OBJECT_TABLE *)
 555             (ctx->bios + data_offset +
 556              le16_to_cpu(obj_header->usConnectorObjectTableOffset));
 557         enc_obj = (ATOM_ENCODER_OBJECT_TABLE *)
 558             (ctx->bios + data_offset +
 559              le16_to_cpu(obj_header->usEncoderObjectTableOffset));
 560         router_obj = (ATOM_OBJECT_TABLE *)
 561                 (ctx->bios + data_offset +
 562                  le16_to_cpu(obj_header->usRouterObjectTableOffset));
 563         device_support = le16_to_cpu(obj_header->usDeviceSupport);
 564
 565         path_size = 0;
 566         for (i = 0; i < path_obj->ucNumOfDispPath; i++) {
 567                 uint8_t *addr = (uint8_t *) path_obj->asDispPath;
 568                 ATOM_DISPLAY_OBJECT_PATH *path;
 569                 addr += path_size;
 570                 path = (ATOM_DISPLAY_OBJECT_PATH *) addr;
 571                 path_size += le16_to_cpu(path->usSize);
 572
 573                 if (device_support & le16_to_cpu(path->usDeviceTag)) {
 574                         uint8_t con_obj_id, con_obj_num, con_obj_type;
 575
 576                         con_obj_id =
 577                             (le16_to_cpu(path->usConnObjectId) & OBJECT_ID_MASK)
 578                             >> OBJECT_ID_SHIFT;
 579                         con_obj_num =
 580                             (le16_to_cpu(path->usConnObjectId) & ENUM_ID_MASK)
 581                             >> ENUM_ID_SHIFT;
 582                         con_obj_type =
 583                             (le16_to_cpu(path->usConnObjectId) &
 584                              OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
 585
 586                         /* TODO CV support */
 587                         if (le16_to_cpu(path->usDeviceTag) ==
 588                                 ATOM_DEVICE_CV_SUPPORT)
 589                                 continue;
 590
 591                         /* IGP chips */
 592                         if ((rdev->flags & RADEON_IS_IGP) &&
 593                             (con_obj_id ==
 594                              CONNECTOR_OBJECT_ID_PCIE_CONNECTOR)) {
 595                                 uint16_t igp_offset = 0;
 596                                 ATOM_INTEGRATED_SYSTEM_INFO_V2 *igp_obj;
 597
 598                                 index =
 599                                     GetIndexIntoMasterTable(DATA,
 600                                                             IntegratedSystemInfo);
 601
 602                                 if (atom_parse_data_header(ctx, index, &size, &frev,
 603                                                            &crev, &igp_offset)) {
 604
 605                                         if (crev >= 2) {
 606                                                 igp_obj =
 607                                                         (ATOM_INTEGRATED_SYSTEM_INFO_V2
 608                                                          *) (ctx->bios + igp_offset);
 609
 610                                                 if (igp_obj) {
 611                                                         uint32_t slot_config, ct;
 612
 613                                                         if (con_obj_num == 1)
 614                                                                 slot_config =
 615                                                                         igp_obj->
 616                                                                         ulDDISlot1Config;
 617                                                         else
 618                                                                 slot_config =
 619                                                                         igp_obj->
 620                                                                         ulDDISlot2Config;
 621
 622                                                         ct = (slot_config >> 16) & 0xff;
 623                                                         connector_type =
 624                                                                 object_connector_convert
 625                                                                 [ct];
 626                                                         connector_object_id = ct;
 627                                                         igp_lane_info =
 628                                                                 slot_config & 0xffff;
 629                                                 } else
 630                                                         continue;
 631                                         } else
 632                                                 continue;
 633                                 } else {
 634                                         igp_lane_info = 0;
 635                                         connector_type =
 636                                                 object_connector_convert[con_obj_id];
 637                                         connector_object_id = con_obj_id;
 638                                 }
 639                         } else {
 640                                 igp_lane_info = 0;
 641                                 connector_type =
 642                                     object_connector_convert[con_obj_id];
 643                                 connector_object_id = con_obj_id;
 644                         }
 645
 646                         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
 647                                 continue;
 648
 649                         router.ddc_valid = false;
 650                         router.cd_valid = false;
 651                         for (j = 0; j < ((le16_to_cpu(path->usSize) - 8) / 2); j++) {
 652                                 uint8_t grph_obj_id, grph_obj_num, grph_obj_type;
 653
 654                                 grph_obj_id =
 655                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
 656                                      OBJECT_ID_MASK) >> OBJECT_ID_SHIFT;
 657                                 grph_obj_num =
 658                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
 659                                      ENUM_ID_MASK) >> ENUM_ID_SHIFT;
 660                                 grph_obj_type =
 661                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
 662                                      OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
 663
 664                                 if (grph_obj_type == GRAPH_OBJECT_TYPE_ENCODER) {
 665                                         for (k = 0; k < enc_obj->ucNumberOfObjects; k++) {
 666                                                 u16 encoder_obj = le16_to_cpu(enc_obj->asObjects[k].usObjectID);
 667                                                 if (le16_to_cpu(path->usGraphicObjIds[j]) == encoder_obj) {
 668                                                         ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
 669                                                                 (ctx->bios + data_offset +
 670                                                                  le16_to_cpu(enc_obj->asObjects[k].usRecordOffset));
 671                                                         ATOM_ENCODER_CAP_RECORD *cap_record;
 672                                                         u16 caps = 0;
 673
 674                                                         while (record->ucRecordSize > 0 &&
 675                                                                record->ucRecordType > 0 &&
 676                                                                record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
 677                                                                 switch (record->ucRecordType) {
 678                                                                 case ATOM_ENCODER_CAP_RECORD_TYPE:
 679                                                                         cap_record =(ATOM_ENCODER_CAP_RECORD *)
 680                                                                                 record;
 681                                                                         caps = le16_to_cpu(cap_record->usEncoderCap);
 682                                                                         break;
 683                                                                 }
 684                                                                 record = (ATOM_COMMON_RECORD_HEADER *)
 685                                                                         ((char *)record + record->ucRecordSize);
 686                                                         }
 687                                                         radeon_add_atom_encoder(dev,
 688                                                                                 encoder_obj,
 689                                                                                 le16_to_cpu
 690                                                                                 (path->
 691                                                                                  usDeviceTag),
 692                                                                                 caps);
 693                                                 }
 694                                         }
 695                                 } else if (grph_obj_type == GRAPH_OBJECT_TYPE_ROUTER) {
 696                                         for (k = 0; k < router_obj->ucNumberOfObjects; k++) {
 697                                                 u16 router_obj_id = le16_to_cpu(router_obj->asObjects[k].usObjectID);
 698                                                 if (le16_to_cpu(path->usGraphicObjIds[j]) == router_obj_id) {
 699                                                         ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
 700                                                                 (ctx->bios + data_offset +
 701                                                                  le16_to_cpu(router_obj->asObjects[k].usRecordOffset));
 702                                                         ATOM_I2C_RECORD *i2c_record;
 703                                                         ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
 704                                                         ATOM_ROUTER_DDC_PATH_SELECT_RECORD *ddc_path;
 705                                                         ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *cd_path;
 706                                                         ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *router_src_dst_table =
 707                                                                 (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *)
 708                                                                 (ctx->bios + data_offset +
 709                                                                  le16_to_cpu(router_obj->asObjects[k].usSrcDstTableOffset));
 710                                                         u8 *num_dst_objs = (u8 *)
 711                                                                 ((u8 *)router_src_dst_table + 1 +
 712                                                                  (router_src_dst_table->ucNumberOfSrc * 2));
 713                                                         u16 *dst_objs = (u16 *)(num_dst_objs + 1);
 714                                                         int enum_id;
 715
 716                                                         router.router_id = router_obj_id;
 717                                                         for (enum_id = 0; enum_id < (*num_dst_objs); enum_id++) {
 718                                                                 if (le16_to_cpu(path->usConnObjectId) ==
 719                                                                     le16_to_cpu(dst_objs[enum_id]))
 720                                                                         break;
 721                                                         }
 722
 723                                                         while (record->ucRecordSize > 0 &&
 724                                                                record->ucRecordType > 0 &&
 725                                                                record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
 726                                                                 switch (record->ucRecordType) {
 727                                                                 case ATOM_I2C_RECORD_TYPE:
 728                                                                         i2c_record =
 729                                                                                 (ATOM_I2C_RECORD *)
 730                                                                                 record;
 731                                                                         i2c_config =
 732                                                                                 (ATOM_I2C_ID_CONFIG_ACCESS *)
 733                                                                                 &i2c_record->sucI2cId;
 734                                                                         router.i2c_info =
 735                                                                                 radeon_lookup_i2c_gpio(rdev,
 736                                                                                                        i2c_config->
 737                                                                                                        ucAccess);
 738                                                                         router.i2c_addr = i2c_record->ucI2CAddr >> 1;
 739                                                                         break;
 740                                                                 case ATOM_ROUTER_DDC_PATH_SELECT_RECORD_TYPE:
 741                                                                         ddc_path = (ATOM_ROUTER_DDC_PATH_SELECT_RECORD *)
 742                                                                                 record;
 743                                                                         router.ddc_valid = true;
 744                                                                         router.ddc_mux_type = ddc_path->ucMuxType;
 745                                                                         router.ddc_mux_control_pin = ddc_path->ucMuxControlPin;
 746                                                                         router.ddc_mux_state = ddc_path->ucMuxState[enum_id];
 747                                                                         break;
 748                                                                 case ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD_TYPE:
 749                                                                         cd_path = (ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *)
 750                                                                                 record;
 751                                                                         router.cd_valid = true;
 752                                                                         router.cd_mux_type = cd_path->ucMuxType;
 753                                                                         router.cd_mux_control_pin = cd_path->ucMuxControlPin;
 754                                                                         router.cd_mux_state = cd_path->ucMuxState[enum_id];
 755                                                                         break;
 756                                                                 }
 757                                                                 record = (ATOM_COMMON_RECORD_HEADER *)
 758                                                                         ((char *)record + record->ucRecordSize);
 759                                                         }
 760                                                 }
 761                                         }
 762                                 }
 763                         }
 764
 765                         /* look up gpio for ddc, hpd */
 766                         ddc_bus.valid = false;
 767                         hpd.hpd = RADEON_HPD_NONE;
 768                         if ((le16_to_cpu(path->usDeviceTag) &
 769                              (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) == 0) {
 770                                 for (j = 0; j < con_obj->ucNumberOfObjects; j++) {
 771                                         if (le16_to_cpu(path->usConnObjectId) ==
 772                                             le16_to_cpu(con_obj->asObjects[j].
 773                                                         usObjectID)) {
 774                                                 ATOM_COMMON_RECORD_HEADER
 775                                                     *record =
 776                                                     (ATOM_COMMON_RECORD_HEADER
 777                                                      *)
 778                                                     (ctx->bios + data_offset +
 779                                                      le16_to_cpu(con_obj->
 780                                                                  asObjects[j].
 781                                                                  usRecordOffset));
 782                                                 ATOM_I2C_RECORD *i2c_record;
 783                                                 ATOM_HPD_INT_RECORD *hpd_record;
 784                                                 ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
 785
 786                                                 while (record->ucRecordSize > 0 &&
 787                                                        record->ucRecordType > 0 &&
 788                                                        record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
 789                                                         switch (record->ucRecordType) {
 790                                                         case ATOM_I2C_RECORD_TYPE:
 791                                                                 i2c_record =
 792                                                                     (ATOM_I2C_RECORD *)
 793                                                                         record;
 794                                                                 i2c_config =
 795                                                                         (ATOM_I2C_ID_CONFIG_ACCESS *)
 796                                                                         &i2c_record->sucI2cId;
 797                                                                 ddc_bus = radeon_lookup_i2c_gpio(rdev,
 798                                                                                                  i2c_config->
 799                                                                                                  ucAccess);
 800                                                                 break;
 801                                                         case ATOM_HPD_INT_RECORD_TYPE:
 802                                                                 hpd_record =
 803                                                                         (ATOM_HPD_INT_RECORD *)
 804                                                                         record;
 805                                                                 gpio = radeon_atombios_lookup_gpio(rdev,
 806                                                                                           hpd_record->ucHPDIntGPIOID);
 807                                                                 hpd = radeon_atom_get_hpd_info_from_gpio(rdev, &gpio);
 808                                                                 hpd.plugged_state = hpd_record->ucPlugged_PinState;
 809                                                                 break;
 810                                                         }
 811                                                         record =
 812                                                             (ATOM_COMMON_RECORD_HEADER
 813                                                              *) ((char *)record
 814                                                                  +
 815                                                                  record->
 816                                                                  ucRecordSize);
 817                                                 }
 818                                                 break;
 819                                         }
 820                                 }
 821                         }
 822
 823                         /* needed for aux chan transactions */
 824                         ddc_bus.hpd = hpd.hpd;
 825
 826                         conn_id = le16_to_cpu(path->usConnObjectId);
 827
 828                         if (!radeon_atom_apply_quirks
 829                             (dev, le16_to_cpu(path->usDeviceTag), &connector_type,
 830                              &ddc_bus, &conn_id, &hpd))
 831                                 continue;
 832
 833                         radeon_add_atom_connector(dev,
 834                                                   conn_id,
 835                                                   le16_to_cpu(path->
 836                                                               usDeviceTag),
 837                                                   connector_type, &ddc_bus,
 838                                                   igp_lane_info,
 839                                                   connector_object_id,
 840                                                   &hpd,
 841                                                   &router);
 842
 843                 }
 844         }
 845
 846         radeon_link_encoder_connector(dev);
 847
 848         return true;
 849 }
 850
 851 static uint16_t atombios_get_connector_object_id(struct drm_device *dev,
 852                                                  int connector_type,
 853                                                  uint16_t devices)
 854 {
 855         struct radeon_device *rdev = dev->dev_private;
 856
 857         if (rdev->flags & RADEON_IS_IGP) {
 858                 return supported_devices_connector_object_id_convert
 859                         [connector_type];
 860         } else if (((connector_type == DRM_MODE_CONNECTOR_DVII) ||
 861                     (connector_type == DRM_MODE_CONNECTOR_DVID)) &&
 862                    (devices & ATOM_DEVICE_DFP2_SUPPORT))  {
 863                 struct radeon_mode_info *mode_info = &rdev->mode_info;
 864                 struct atom_context *ctx = mode_info->atom_context;
 865                 int index = GetIndexIntoMasterTable(DATA, XTMDS_Info);
 866                 uint16_t size, data_offset;
 867                 uint8_t frev, crev;
 868                 ATOM_XTMDS_INFO *xtmds;
 869
 870                 if (atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset)) {
 871                         xtmds = (ATOM_XTMDS_INFO *)(ctx->bios + data_offset);
 872
 873                         if (xtmds->ucSupportedLink & ATOM_XTMDS_SUPPORTED_DUALLINK) {
 874                                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
 875                                         return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I;
 876                                 else
 877                                         return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D;
 878                         } else {
 879                                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
 880                                         return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I;
 881                                 else
 882                                         return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D;
 883                         }
 884                 } else
 885                         return supported_devices_connector_object_id_convert
 886                                 [connector_type];
 887         } else {
 888                 return supported_devices_connector_object_id_convert
 889                         [connector_type];
 890         }
 891 }
 892
 893 struct bios_connector {
 894         bool valid;
 895         uint16_t line_mux;
 896         uint16_t devices;
 897         int connector_type;
 898         struct radeon_i2c_bus_rec ddc_bus;
 899         struct radeon_hpd hpd;
 900 };
 901
 902 bool radeon_get_atom_connector_info_from_supported_devices_table(struct
 903                                                                  drm_device
 904                                                                  *dev)
 905 {
 906         struct radeon_device *rdev = dev->dev_private;
 907         struct radeon_mode_info *mode_info = &rdev->mode_info;
 908         struct atom_context *ctx = mode_info->atom_context;
 909         int index = GetIndexIntoMasterTable(DATA, SupportedDevicesInfo);
 910         uint16_t size, data_offset;
 911         uint8_t frev, crev;
 912         uint16_t device_support;
 913         uint8_t dac;
 914         union atom_supported_devices *supported_devices;
 915         int i, j, max_device;
 916         struct bios_connector *bios_connectors;
 917         size_t bc_size = sizeof(*bios_connectors) * ATOM_MAX_SUPPORTED_DEVICE;
 918         struct radeon_router router;
 919
 920         router.ddc_valid = false;
 921         router.cd_valid = false;
 922
 923         bios_connectors = kzalloc(bc_size, GFP_KERNEL);
 924         if (!bios_connectors)
 925                 return false;
 926
 927         if (!atom_parse_data_header(ctx, index, &size, &frev, &crev,
 928                                     &data_offset)) {
 929                 kfree(bios_connectors);
 930                 return false;
 931         }
 932
 933         supported_devices =
 934             (union atom_supported_devices *)(ctx->bios + data_offset);
 935
 936         device_support = le16_to_cpu(supported_devices->info.usDeviceSupport);
 937
 938         if (frev > 1)
 939                 max_device = ATOM_MAX_SUPPORTED_DEVICE;
 940         else
 941                 max_device = ATOM_MAX_SUPPORTED_DEVICE_INFO;
 942
 943         for (i = 0; i < max_device; i++) {
 944                 ATOM_CONNECTOR_INFO_I2C ci =
 945                     supported_devices->info.asConnInfo[i];
 946
 947                 bios_connectors[i].valid = false;
 948
 949                 if (!(device_support & (1 << i))) {
 950                         continue;
 951                 }
 952
 953                 if (i == ATOM_DEVICE_CV_INDEX) {
 954                         DRM_DEBUG_KMS("Skipping Component Video\n");
 955                         continue;
 956                 }
 957
 958                 bios_connectors[i].connector_type =
 959                     supported_devices_connector_convert[ci.sucConnectorInfo.
 960                                                         sbfAccess.
 961                                                         bfConnectorType];
 962
 963                 if (bios_connectors[i].connector_type ==
 964                     DRM_MODE_CONNECTOR_Unknown)
 965                         continue;
 966
 967                 dac = ci.sucConnectorInfo.sbfAccess.bfAssociatedDAC;
 968
 969                 bios_connectors[i].line_mux =
 970                         ci.sucI2cId.ucAccess;
 971
 972                 /* give tv unique connector ids */
 973                 if (i == ATOM_DEVICE_TV1_INDEX) {
 974                         bios_connectors[i].ddc_bus.valid = false;
 975                         bios_connectors[i].line_mux = 50;
 976                 } else if (i == ATOM_DEVICE_TV2_INDEX) {
 977                         bios_connectors[i].ddc_bus.valid = false;
 978                         bios_connectors[i].line_mux = 51;
 979                 } else if (i == ATOM_DEVICE_CV_INDEX) {
 980                         bios_connectors[i].ddc_bus.valid = false;
 981                         bios_connectors[i].line_mux = 52;
 982                 } else
 983                         bios_connectors[i].ddc_bus =
 984                             radeon_lookup_i2c_gpio(rdev,
 985                                                    bios_connectors[i].line_mux);
 986
 987                 if ((crev > 1) && (frev > 1)) {
 988                         u8 isb = supported_devices->info_2d1.asIntSrcInfo[i].ucIntSrcBitmap;
 989                         switch (isb) {
 990                         case 0x4:
 991                                 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
 992                                 break;
 993                         case 0xa:
 994                                 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
 995                                 break;
 996                         default:
 997                                 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
 998                                 break;
 999                         }
1000                 } else {
1001                         if (i == ATOM_DEVICE_DFP1_INDEX)
1002                                 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
1003                         else if (i == ATOM_DEVICE_DFP2_INDEX)
1004                                 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
1005                         else
1006                                 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
1007                 }
1008
1009                 /* Always set the connector type to VGA for CRT1/CRT2. if they are
1010                  * shared with a DVI port, we'll pick up the DVI connector when we
1011                  * merge the outputs.  Some bioses incorrectly list VGA ports as DVI.
1012                  */
1013                 if (i == ATOM_DEVICE_CRT1_INDEX || i == ATOM_DEVICE_CRT2_INDEX)
1014                         bios_connectors[i].connector_type =
1015                             DRM_MODE_CONNECTOR_VGA;
1016
1017                 if (!radeon_atom_apply_quirks
1018                     (dev, (1 << i), &bios_connectors[i].connector_type,
1019                      &bios_connectors[i].ddc_bus, &bios_connectors[i].line_mux,
1020                      &bios_connectors[i].hpd))
1021                         continue;
1022
1023                 bios_connectors[i].valid = true;
1024                 bios_connectors[i].devices = (1 << i);
1025
1026                 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom)
1027                         radeon_add_atom_encoder(dev,
1028                                                 radeon_get_encoder_enum(dev,
1029                                                                       (1 << i),
1030                                                                       dac),
1031                                                 (1 << i),
1032                                                 0);
1033                 else
1034                         radeon_add_legacy_encoder(dev,
1035                                                   radeon_get_encoder_enum(dev,
1036                                                                         (1 << i),
1037                                                                         dac),
1038                                                   (1 << i));
1039         }
1040
1041         /* combine shared connectors */
1042         for (i = 0; i < max_device; i++) {
1043                 if (bios_connectors[i].valid) {
1044                         for (j = 0; j < max_device; j++) {
1045                                 if (bios_connectors[j].valid && (i != j)) {
1046                                         if (bios_connectors[i].line_mux ==
1047                                             bios_connectors[j].line_mux) {
1048                                                 /* make sure not to combine LVDS */
1049                                                 if (bios_connectors[i].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1050                                                         bios_connectors[i].line_mux = 53;
1051                                                         bios_connectors[i].ddc_bus.valid = false;
1052                                                         continue;
1053                                                 }
1054                                                 if (bios_connectors[j].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1055                                                         bios_connectors[j].line_mux = 53;
1056                                                         bios_connectors[j].ddc_bus.valid = false;
1057                                                         continue;
1058                                                 }
1059                                                 /* combine analog and digital for DVI-I */
1060                                                 if (((bios_connectors[i].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1061                                                      (bios_connectors[j].devices & (ATOM_DEVICE_CRT_SUPPORT))) ||
1062                                                     ((bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1063                                                      (bios_connectors[i].devices & (ATOM_DEVICE_CRT_SUPPORT)))) {
1064                                                         bios_connectors[i].devices |=
1065                                                                 bios_connectors[j].devices;
1066                                                         bios_connectors[i].connector_type =
1067                                                                 DRM_MODE_CONNECTOR_DVII;
1068                                                         if (bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT))
1069                                                                 bios_connectors[i].hpd =
1070                                                                         bios_connectors[j].hpd;
1071                                                         bios_connectors[j].valid = false;
1072                                                 }
1073                                         }
1074                                 }
1075                         }
1076                 }
1077         }
1078
1079         /* add the connectors */
1080         for (i = 0; i < max_device; i++) {
1081                 if (bios_connectors[i].valid) {
1082                         uint16_t connector_object_id =
1083                                 atombios_get_connector_object_id(dev,
1084                                                       bios_connectors[i].connector_type,
1085                                                       bios_connectors[i].devices);
1086                         radeon_add_atom_connector(dev,
1087                                                   bios_connectors[i].line_mux,
1088                                                   bios_connectors[i].devices,
1089                                                   bios_connectors[i].
1090                                                   connector_type,
1091                                                   &bios_connectors[i].ddc_bus,
1092                                                   0,
1093                                                   connector_object_id,
1094                                                   &bios_connectors[i].hpd,
1095                                                   &router);
1096                 }
1097         }
1098
1099         radeon_link_encoder_connector(dev);
1100
1101         kfree(bios_connectors);
1102         return true;
1103 }
1104
1105 union firmware_info {
1106         ATOM_FIRMWARE_INFO info;
1107         ATOM_FIRMWARE_INFO_V1_2 info_12;
1108         ATOM_FIRMWARE_INFO_V1_3 info_13;
1109         ATOM_FIRMWARE_INFO_V1_4 info_14;
1110         ATOM_FIRMWARE_INFO_V2_1 info_21;
1111         ATOM_FIRMWARE_INFO_V2_2 info_22;
1112 };
1113
1114 bool radeon_atom_get_clock_info(struct drm_device *dev)
1115 {
1116         struct radeon_device *rdev = dev->dev_private;
1117         struct radeon_mode_info *mode_info = &rdev->mode_info;
1118         int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
1119         union firmware_info *firmware_info;
1120         uint8_t frev, crev;
1121         struct radeon_pll *p1pll = &rdev->clock.p1pll;
1122         struct radeon_pll *p2pll = &rdev->clock.p2pll;
1123         struct radeon_pll *dcpll = &rdev->clock.dcpll;
1124         struct radeon_pll *spll = &rdev->clock.spll;
1125         struct radeon_pll *mpll = &rdev->clock.mpll;
1126         uint16_t data_offset;
1127
1128         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1129                                    &frev, &crev, &data_offset)) {
1130                 firmware_info =
1131                         (union firmware_info *)(mode_info->atom_context->bios +
1132                                                 data_offset);
1133                 /* pixel clocks */
1134                 p1pll->reference_freq =
1135                     le16_to_cpu(firmware_info->info.usReferenceClock);
1136                 p1pll->reference_div = 0;
1137
1138                 if (crev < 2)
1139                         p1pll->pll_out_min =
1140                                 le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Output);
1141                 else
1142                         p1pll->pll_out_min =
1143                                 le32_to_cpu(firmware_info->info_12.ulMinPixelClockPLL_Output);
1144                 p1pll->pll_out_max =
1145                     le32_to_cpu(firmware_info->info.ulMaxPixelClockPLL_Output);
1146
1147                 if (crev >= 4) {
1148                         p1pll->lcd_pll_out_min =
1149                                 le16_to_cpu(firmware_info->info_14.usLcdMinPixelClockPLL_Output) * 100;
1150                         if (p1pll->lcd_pll_out_min == 0)
1151                                 p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1152                         p1pll->lcd_pll_out_max =
1153                                 le16_to_cpu(firmware_info->info_14.usLcdMaxPixelClockPLL_Output) * 100;
1154                         if (p1pll->lcd_pll_out_max == 0)
1155                                 p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1156                 } else {
1157                         p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1158                         p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1159                 }
1160
1161                 if (p1pll->pll_out_min == 0) {
1162                         if (ASIC_IS_AVIVO(rdev))
1163                                 p1pll->pll_out_min = 64800;
1164                         else
1165                                 p1pll->pll_out_min = 20000;
1166                 }
1167
1168                 p1pll->pll_in_min =
1169                     le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Input);
1170                 p1pll->pll_in_max =
1171                     le16_to_cpu(firmware_info->info.usMaxPixelClockPLL_Input);
1172
1173                 *p2pll = *p1pll;
1174
1175                 /* system clock */
1176                 if (ASIC_IS_DCE4(rdev))
1177                         spll->reference_freq =
1178                                 le16_to_cpu(firmware_info->info_21.usCoreReferenceClock);
1179                 else
1180                         spll->reference_freq =
1181                                 le16_to_cpu(firmware_info->info.usReferenceClock);
1182                 spll->reference_div = 0;
1183
1184                 spll->pll_out_min =
1185                     le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Output);
1186                 spll->pll_out_max =
1187                     le32_to_cpu(firmware_info->info.ulMaxEngineClockPLL_Output);
1188
1189                 /* ??? */
1190                 if (spll->pll_out_min == 0) {
1191                         if (ASIC_IS_AVIVO(rdev))
1192                                 spll->pll_out_min = 64800;
1193                         else
1194                                 spll->pll_out_min = 20000;
1195                 }
1196
1197                 spll->pll_in_min =
1198                     le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Input);
1199                 spll->pll_in_max =
1200                     le16_to_cpu(firmware_info->info.usMaxEngineClockPLL_Input);
1201
1202                 /* memory clock */
1203                 if (ASIC_IS_DCE4(rdev))
1204                         mpll->reference_freq =
1205                                 le16_to_cpu(firmware_info->info_21.usMemoryReferenceClock);
1206                 else
1207                         mpll->reference_freq =
1208                                 le16_to_cpu(firmware_info->info.usReferenceClock);
1209                 mpll->reference_div = 0;
1210
1211                 mpll->pll_out_min =
1212                     le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Output);
1213                 mpll->pll_out_max =
1214                     le32_to_cpu(firmware_info->info.ulMaxMemoryClockPLL_Output);
1215
1216                 /* ??? */
1217                 if (mpll->pll_out_min == 0) {
1218                         if (ASIC_IS_AVIVO(rdev))
1219                                 mpll->pll_out_min = 64800;
1220                         else
1221                                 mpll->pll_out_min = 20000;
1222                 }
1223
1224                 mpll->pll_in_min =
1225                     le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Input);
1226                 mpll->pll_in_max =
1227                     le16_to_cpu(firmware_info->info.usMaxMemoryClockPLL_Input);
1228
1229                 rdev->clock.default_sclk =
1230                     le32_to_cpu(firmware_info->info.ulDefaultEngineClock);
1231                 rdev->clock.default_mclk =
1232                     le32_to_cpu(firmware_info->info.ulDefaultMemoryClock);
1233
1234                 if (ASIC_IS_DCE4(rdev)) {
1235                         rdev->clock.default_dispclk =
1236                                 le32_to_cpu(firmware_info->info_21.ulDefaultDispEngineClkFreq);
1237                         if (rdev->clock.default_dispclk == 0) {
1238                                 if (ASIC_IS_DCE6(rdev))
1239                                         rdev->clock.default_dispclk = 60000; /* 600 Mhz */
1240                                 else if (ASIC_IS_DCE5(rdev))
1241                                         rdev->clock.default_dispclk = 54000; /* 540 Mhz */
1242                                 else
1243                                         rdev->clock.default_dispclk = 60000; /* 600 Mhz */
1244                         }
1245                         /* set a reasonable default for DP */
1246                         if (ASIC_IS_DCE6(rdev) && (rdev->clock.default_dispclk < 53900)) {
1247                                 DRM_INFO("Changing default dispclk from %dMhz to 600Mhz\n",
1248                                          rdev->clock.default_dispclk / 100);
1249                                 rdev->clock.default_dispclk = 60000;
1250                         }
1251                         rdev->clock.dp_extclk =
1252                                 le16_to_cpu(firmware_info->info_21.usUniphyDPModeExtClkFreq);
1253                         rdev->clock.current_dispclk = rdev->clock.default_dispclk;
1254                 }
1255                 *dcpll = *p1pll;
1256
1257                 rdev->clock.max_pixel_clock = le16_to_cpu(firmware_info->info.usMaxPixelClock);
1258                 if (rdev->clock.max_pixel_clock == 0)
1259                         rdev->clock.max_pixel_clock = 40000;
1260
1261                 /* not technically a clock, but... */
1262                 rdev->mode_info.firmware_flags =
1263                         le16_to_cpu(firmware_info->info.usFirmwareCapability.susAccess);
1264
1265                 return true;
1266         }
1267
1268         return false;
1269 }
1270
1271 union igp_info {
1272         struct _ATOM_INTEGRATED_SYSTEM_INFO info;
1273         struct _ATOM_INTEGRATED_SYSTEM_INFO_V2 info_2;
1274         struct _ATOM_INTEGRATED_SYSTEM_INFO_V6 info_6;
1275         struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_7 info_7;
1276         struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_8 info_8;
1277 };
1278
1279 bool radeon_atombios_sideport_present(struct radeon_device *rdev)
1280 {
1281         struct radeon_mode_info *mode_info = &rdev->mode_info;
1282         int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1283         union igp_info *igp_info;
1284         u8 frev, crev;
1285         u16 data_offset;
1286
1287         /* sideport is AMD only */
1288         if (rdev->family == CHIP_RS600)
1289                 return false;
1290
1291         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1292                                    &frev, &crev, &data_offset)) {
1293                 igp_info = (union igp_info *)(mode_info->atom_context->bios +
1294                                       data_offset);
1295                 switch (crev) {
1296                 case 1:
1297                         if (le32_to_cpu(igp_info->info.ulBootUpMemoryClock))
1298                                 return true;
1299                         break;
1300                 case 2:
1301                         if (le32_to_cpu(igp_info->info_2.ulBootUpSidePortClock))
1302                                 return true;
1303                         break;
1304                 default:
1305                         DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
1306                         break;
1307                 }
1308         }
1309         return false;
1310 }
1311
1312 bool radeon_atombios_get_tmds_info(struct radeon_encoder *encoder,
1313                                    struct radeon_encoder_int_tmds *tmds)
1314 {
1315         struct drm_device *dev = encoder->base.dev;
1316         struct radeon_device *rdev = dev->dev_private;
1317         struct radeon_mode_info *mode_info = &rdev->mode_info;
1318         int index = GetIndexIntoMasterTable(DATA, TMDS_Info);
1319         uint16_t data_offset;
1320         struct _ATOM_TMDS_INFO *tmds_info;
1321         uint8_t frev, crev;
1322         uint16_t maxfreq;
1323         int i;
1324
1325         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1326                                    &frev, &crev, &data_offset)) {
1327                 tmds_info =
1328                         (struct _ATOM_TMDS_INFO *)(mode_info->atom_context->bios +
1329                                                    data_offset);
1330
1331                 maxfreq = le16_to_cpu(tmds_info->usMaxFrequency);
1332                 for (i = 0; i < 4; i++) {
1333                         tmds->tmds_pll[i].freq =
1334                             le16_to_cpu(tmds_info->asMiscInfo[i].usFrequency);
1335                         tmds->tmds_pll[i].value =
1336                             tmds_info->asMiscInfo[i].ucPLL_ChargePump & 0x3f;
1337                         tmds->tmds_pll[i].value |=
1338                             (tmds_info->asMiscInfo[i].
1339                              ucPLL_VCO_Gain & 0x3f) << 6;
1340                         tmds->tmds_pll[i].value |=
1341                             (tmds_info->asMiscInfo[i].
1342                              ucPLL_DutyCycle & 0xf) << 12;
1343                         tmds->tmds_pll[i].value |=
1344                             (tmds_info->asMiscInfo[i].
1345                              ucPLL_VoltageSwing & 0xf) << 16;
1346
1347                         DRM_DEBUG_KMS("TMDS PLL From ATOMBIOS %u %x\n",
1348                                   tmds->tmds_pll[i].freq,
1349                                   tmds->tmds_pll[i].value);
1350
1351                         if (maxfreq == tmds->tmds_pll[i].freq) {
1352                                 tmds->tmds_pll[i].freq = 0xffffffff;
1353                                 break;
1354                         }
1355                 }
1356                 return true;
1357         }
1358         return false;
1359 }
1360
1361 bool radeon_atombios_get_ppll_ss_info(struct radeon_device *rdev,
1362                                       struct radeon_atom_ss *ss,
1363                                       int id)
1364 {
1365         struct radeon_mode_info *mode_info = &rdev->mode_info;
1366         int index = GetIndexIntoMasterTable(DATA, PPLL_SS_Info);
1367         uint16_t data_offset, size;
1368         struct _ATOM_SPREAD_SPECTRUM_INFO *ss_info;
1369         struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT *ss_assign;
1370         uint8_t frev, crev;
1371         int i, num_indices;
1372
1373         memset(ss, 0, sizeof(struct radeon_atom_ss));
1374         if (atom_parse_data_header(mode_info->atom_context, index, &size,
1375                                    &frev, &crev, &data_offset)) {
1376                 ss_info =
1377                         (struct _ATOM_SPREAD_SPECTRUM_INFO *)(mode_info->atom_context->bios + data_offset);
1378
1379                 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1380                         sizeof(ATOM_SPREAD_SPECTRUM_ASSIGNMENT);
1381                 ss_assign = (struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT*)
1382                         ((u8 *)&ss_info->asSS_Info[0]);
1383                 for (i = 0; i < num_indices; i++) {
1384                         if (ss_assign->ucSS_Id == id) {
1385                                 ss->percentage =
1386                                         le16_to_cpu(ss_assign->usSpreadSpectrumPercentage);
1387                                 ss->type = ss_assign->ucSpreadSpectrumType;
1388                                 ss->step = ss_assign->ucSS_Step;
1389                                 ss->delay = ss_assign->ucSS_Delay;
1390                                 ss->range = ss_assign->ucSS_Range;
1391                                 ss->refdiv = ss_assign->ucRecommendedRef_Div;
1392                                 return true;
1393                         }
1394                         ss_assign = (struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT*)
1395                                 ((u8 *)ss_assign + sizeof(struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT));
1396                 }
1397         }
1398         return false;
1399 }
1400
1401 static void radeon_atombios_get_igp_ss_overrides(struct radeon_device *rdev,
1402                                                  struct radeon_atom_ss *ss,
1403                                                  int id)
1404 {
1405         struct radeon_mode_info *mode_info = &rdev->mode_info;
1406         int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1407         u16 data_offset, size;
1408         union igp_info *igp_info;
1409         u8 frev, crev;
1410         u16 percentage = 0, rate = 0;
1411
1412         /* get any igp specific overrides */
1413         if (atom_parse_data_header(mode_info->atom_context, index, &size,
1414                                    &frev, &crev, &data_offset)) {
1415                 igp_info = (union igp_info *)
1416                         (mode_info->atom_context->bios + data_offset);
1417                 switch (crev) {
1418                 case 6:
1419                         switch (id) {
1420                         case ASIC_INTERNAL_SS_ON_TMDS:
1421                                 percentage = le16_to_cpu(igp_info->info_6.usDVISSPercentage);
1422                                 rate = le16_to_cpu(igp_info->info_6.usDVISSpreadRateIn10Hz);
1423                                 break;
1424                         case ASIC_INTERNAL_SS_ON_HDMI:
1425                                 percentage = le16_to_cpu(igp_info->info_6.usHDMISSPercentage);
1426                                 rate = le16_to_cpu(igp_info->info_6.usHDMISSpreadRateIn10Hz);
1427                                 break;
1428                         case ASIC_INTERNAL_SS_ON_LVDS:
1429                                 percentage = le16_to_cpu(igp_info->info_6.usLvdsSSPercentage);
1430                                 rate = le16_to_cpu(igp_info->info_6.usLvdsSSpreadRateIn10Hz);
1431                                 break;
1432                         }
1433                         break;
1434                 case 7:
1435                         switch (id) {
1436                         case ASIC_INTERNAL_SS_ON_TMDS:
1437                                 percentage = le16_to_cpu(igp_info->info_7.usDVISSPercentage);
1438                                 rate = le16_to_cpu(igp_info->info_7.usDVISSpreadRateIn10Hz);
1439                                 break;
1440                         case ASIC_INTERNAL_SS_ON_HDMI:
1441                                 percentage = le16_to_cpu(igp_info->info_7.usHDMISSPercentage);
1442                                 rate = le16_to_cpu(igp_info->info_7.usHDMISSpreadRateIn10Hz);
1443                                 break;
1444                         case ASIC_INTERNAL_SS_ON_LVDS:
1445                                 percentage = le16_to_cpu(igp_info->info_7.usLvdsSSPercentage);
1446                                 rate = le16_to_cpu(igp_info->info_7.usLvdsSSpreadRateIn10Hz);
1447                                 break;
1448                         }
1449                         break;
1450                 case 8:
1451                         switch (id) {
1452                         case ASIC_INTERNAL_SS_ON_TMDS:
1453                                 percentage = le16_to_cpu(igp_info->info_8.usDVISSPercentage);
1454                                 rate = le16_to_cpu(igp_info->info_8.usDVISSpreadRateIn10Hz);
1455                                 break;
1456                         case ASIC_INTERNAL_SS_ON_HDMI:
1457                                 percentage = le16_to_cpu(igp_info->info_8.usHDMISSPercentage);
1458                                 rate = le16_to_cpu(igp_info->info_8.usHDMISSpreadRateIn10Hz);
1459                                 break;
1460                         case ASIC_INTERNAL_SS_ON_LVDS:
1461                                 percentage = le16_to_cpu(igp_info->info_8.usLvdsSSPercentage);
1462                                 rate = le16_to_cpu(igp_info->info_8.usLvdsSSpreadRateIn10Hz);
1463                                 break;
1464                         }
1465                         break;
1466                 default:
1467                         DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
1468                         break;
1469                 }
1470                 if (percentage)
1471                         ss->percentage = percentage;
1472                 if (rate)
1473                         ss->rate = rate;
1474         }
1475 }
1476
1477 union asic_ss_info {
1478         struct _ATOM_ASIC_INTERNAL_SS_INFO info;
1479         struct _ATOM_ASIC_INTERNAL_SS_INFO_V2 info_2;
1480         struct _ATOM_ASIC_INTERNAL_SS_INFO_V3 info_3;
1481 };
1482
1483 union asic_ss_assignment {
1484         struct _ATOM_ASIC_SS_ASSIGNMENT v1;
1485         struct _ATOM_ASIC_SS_ASSIGNMENT_V2 v2;
1486         struct _ATOM_ASIC_SS_ASSIGNMENT_V3 v3;
1487 };
1488
1489 bool radeon_atombios_get_asic_ss_info(struct radeon_device *rdev,
1490                                       struct radeon_atom_ss *ss,
1491                                       int id, u32 clock)
1492 {
1493         struct radeon_mode_info *mode_info = &rdev->mode_info;
1494         int index = GetIndexIntoMasterTable(DATA, ASIC_InternalSS_Info);
1495         uint16_t data_offset, size;
1496         union asic_ss_info *ss_info;
1497         union asic_ss_assignment *ss_assign;
1498         uint8_t frev, crev;
1499         int i, num_indices;
1500
1501         if (id == ASIC_INTERNAL_MEMORY_SS) {
1502                 if (!(rdev->mode_info.firmware_flags & ATOM_BIOS_INFO_MEMORY_CLOCK_SS_SUPPORT))
1503                         return false;
1504         }
1505         if (id == ASIC_INTERNAL_ENGINE_SS) {
1506                 if (!(rdev->mode_info.firmware_flags & ATOM_BIOS_INFO_ENGINE_CLOCK_SS_SUPPORT))
1507                         return false;
1508         }
1509
1510         memset(ss, 0, sizeof(struct radeon_atom_ss));
1511         if (atom_parse_data_header(mode_info->atom_context, index, &size,
1512                                    &frev, &crev, &data_offset)) {
1513
1514                 ss_info =
1515                         (union asic_ss_info *)(mode_info->atom_context->bios + data_offset);
1516
1517                 switch (frev) {
1518                 case 1:
1519                         num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1520                                 sizeof(ATOM_ASIC_SS_ASSIGNMENT);
1521
1522                         ss_assign = (union asic_ss_assignment *)((u8 *)&ss_info->info.asSpreadSpectrum[0]);
1523                         for (i = 0; i < num_indices; i++) {
1524                                 if ((ss_assign->v1.ucClockIndication == id) &&
1525                                     (clock <= le32_to_cpu(ss_assign->v1.ulTargetClockRange))) {
1526                                         ss->percentage =
1527                                                 le16_to_cpu(ss_assign->v1.usSpreadSpectrumPercentage);
1528                                         ss->type = ss_assign->v1.ucSpreadSpectrumMode;
1529                                         ss->rate = le16_to_cpu(ss_assign->v1.usSpreadRateInKhz);
1530                                         ss->percentage_divider = 100;
1531                                         return true;
1532                                 }
1533                                 ss_assign = (union asic_ss_assignment *)
1534                                         ((u8 *)ss_assign + sizeof(ATOM_ASIC_SS_ASSIGNMENT));
1535                         }
1536                         break;
1537                 case 2:
1538                         num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1539                                 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V2);
1540                         ss_assign = (union asic_ss_assignment *)((u8 *)&ss_info->info_2.asSpreadSpectrum[0]);
1541                         for (i = 0; i < num_indices; i++) {
1542                                 if ((ss_assign->v2.ucClockIndication == id) &&
1543                                     (clock <= le32_to_cpu(ss_assign->v2.ulTargetClockRange))) {
1544                                         ss->percentage =
1545                                                 le16_to_cpu(ss_assign->v2.usSpreadSpectrumPercentage);
1546                                         ss->type = ss_assign->v2.ucSpreadSpectrumMode;
1547                                         ss->rate = le16_to_cpu(ss_assign->v2.usSpreadRateIn10Hz);
1548                                         ss->percentage_divider = 100;
1549                                         if ((crev == 2) &&
1550                                             ((id == ASIC_INTERNAL_ENGINE_SS) ||
1551                                              (id == ASIC_INTERNAL_MEMORY_SS)))
1552                                                 ss->rate /= 100;
1553                                         return true;
1554                                 }
1555                                 ss_assign = (union asic_ss_assignment *)
1556                                         ((u8 *)ss_assign + sizeof(ATOM_ASIC_SS_ASSIGNMENT_V2));
1557                         }
1558                         break;
1559                 case 3:
1560                         num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1561                                 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V3);
1562                         ss_assign = (union asic_ss_assignment *)((u8 *)&ss_info->info_3.asSpreadSpectrum[0]);
1563                         for (i = 0; i < num_indices; i++) {
1564                                 if ((ss_assign->v3.ucClockIndication == id) &&
1565                                     (clock <= le32_to_cpu(ss_assign->v3.ulTargetClockRange))) {
1566                                         ss->percentage =
1567                                                 le16_to_cpu(ss_assign->v3.usSpreadSpectrumPercentage);
1568                                         ss->type = ss_assign->v3.ucSpreadSpectrumMode;
1569                                         ss->rate = le16_to_cpu(ss_assign->v3.usSpreadRateIn10Hz);
1570                                         if (ss_assign->v3.ucSpreadSpectrumMode &
1571                                             SS_MODE_V3_PERCENTAGE_DIV_BY_1000_MASK)
1572                                                 ss->percentage_divider = 1000;
1573                                         else
1574                                                 ss->percentage_divider = 100;
1575                                         if ((id == ASIC_INTERNAL_ENGINE_SS) ||
1576                                             (id == ASIC_INTERNAL_MEMORY_SS))
1577                                                 ss->rate /= 100;
1578                                         if (rdev->flags & RADEON_IS_IGP)
1579                                                 radeon_atombios_get_igp_ss_overrides(rdev, ss, id);
1580                                         return true;
1581                                 }
1582                                 ss_assign = (union asic_ss_assignment *)
1583                                         ((u8 *)ss_assign + sizeof(ATOM_ASIC_SS_ASSIGNMENT_V3));
1584                         }
1585                         break;
1586                 default:
1587                         DRM_ERROR("Unsupported ASIC_InternalSS_Info table: %d %d\n", frev, crev);
1588                         break;
1589                 }
1590
1591         }
1592         return false;
1593 }
1594
1595 union lvds_info {
1596         struct _ATOM_LVDS_INFO info;
1597         struct _ATOM_LVDS_INFO_V12 info_12;
1598 };
1599
1600 struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
1601                                                               radeon_encoder
1602                                                               *encoder)
1603 {
1604         struct drm_device *dev = encoder->base.dev;
1605         struct radeon_device *rdev = dev->dev_private;
1606         struct radeon_mode_info *mode_info = &rdev->mode_info;
1607         int index = GetIndexIntoMasterTable(DATA, LVDS_Info);
1608         uint16_t data_offset, misc;
1609         union lvds_info *lvds_info;
1610         uint8_t frev, crev;
1611         struct radeon_encoder_atom_dig *lvds = NULL;
1612         int encoder_enum = (encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
1613
1614         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1615                                    &frev, &crev, &data_offset)) {
1616                 lvds_info =
1617                         (union lvds_info *)(mode_info->atom_context->bios + data_offset);
1618                 lvds =
1619                     kzalloc(sizeof(struct radeon_encoder_atom_dig), GFP_KERNEL);
1620
1621                 if (!lvds)
1622                         return NULL;
1623
1624                 lvds->native_mode.clock =
1625                     le16_to_cpu(lvds_info->info.sLCDTiming.usPixClk) * 10;
1626                 lvds->native_mode.hdisplay =
1627                     le16_to_cpu(lvds_info->info.sLCDTiming.usHActive);
1628                 lvds->native_mode.vdisplay =
1629                     le16_to_cpu(lvds_info->info.sLCDTiming.usVActive);
1630                 lvds->native_mode.htotal = lvds->native_mode.hdisplay +
1631                         le16_to_cpu(lvds_info->info.sLCDTiming.usHBlanking_Time);
1632                 lvds->native_mode.hsync_start = lvds->native_mode.hdisplay +
1633                         le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncOffset);
1634                 lvds->native_mode.hsync_end = lvds->native_mode.hsync_start +
1635                         le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncWidth);
1636                 lvds->native_mode.vtotal = lvds->native_mode.vdisplay +
1637                         le16_to_cpu(lvds_info->info.sLCDTiming.usVBlanking_Time);
1638                 lvds->native_mode.vsync_start = lvds->native_mode.vdisplay +
1639                         le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncOffset);
1640                 lvds->native_mode.vsync_end = lvds->native_mode.vsync_start +
1641                         le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncWidth);
1642                 lvds->panel_pwr_delay =
1643                     le16_to_cpu(lvds_info->info.usOffDelayInMs);
1644                 lvds->lcd_misc = lvds_info->info.ucLVDS_Misc;
1645
1646                 misc = le16_to_cpu(lvds_info->info.sLCDTiming.susModeMiscInfo.usAccess);
1647                 if (misc & ATOM_VSYNC_POLARITY)
1648                         lvds->native_mode.flags |= DRM_MODE_FLAG_NVSYNC;
1649                 if (misc & ATOM_HSYNC_POLARITY)
1650                         lvds->native_mode.flags |= DRM_MODE_FLAG_NHSYNC;
1651                 if (misc & ATOM_COMPOSITESYNC)
1652                         lvds->native_mode.flags |= DRM_MODE_FLAG_CSYNC;
1653                 if (misc & ATOM_INTERLACE)
1654                         lvds->native_mode.flags |= DRM_MODE_FLAG_INTERLACE;
1655                 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1656                         lvds->native_mode.flags |= DRM_MODE_FLAG_DBLSCAN;
1657
1658                 lvds->native_mode.width_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageHSize);
1659                 lvds->native_mode.height_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageVSize);
1660
1661                 /* set crtc values */
1662                 drm_mode_set_crtcinfo(&lvds->native_mode, CRTC_INTERLACE_HALVE_V);
1663
1664                 lvds->lcd_ss_id = lvds_info->info.ucSS_Id;
1665
1666                 encoder->native_mode = lvds->native_mode;
1667
1668                 if (encoder_enum == 2)
1669                         lvds->linkb = true;
1670                 else
1671                         lvds->linkb = false;
1672
1673                 /* parse the lcd record table */
1674                 if (le16_to_cpu(lvds_info->info.usModePatchTableOffset)) {
1675                         ATOM_FAKE_EDID_PATCH_RECORD *fake_edid_record;
1676                         ATOM_PANEL_RESOLUTION_PATCH_RECORD *panel_res_record;
1677                         bool bad_record = false;
1678                         u8 *record;
1679
1680                         if ((frev == 1) && (crev < 2))
1681                                 /* absolute */
1682                                 record = (u8 *)(mode_info->atom_context->bios +
1683                                                 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1684                         else
1685                                 /* relative */
1686                                 record = (u8 *)(mode_info->atom_context->bios +
1687                                                 data_offset +
1688                                                 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1689                         while (*record != ATOM_RECORD_END_TYPE) {
1690                                 switch (*record) {
1691                                 case LCD_MODE_PATCH_RECORD_MODE_TYPE:
1692                                         record += sizeof(ATOM_PATCH_RECORD_MODE);
1693                                         break;
1694                                 case LCD_RTS_RECORD_TYPE:
1695                                         record += sizeof(ATOM_LCD_RTS_RECORD);
1696                                         break;
1697                                 case LCD_CAP_RECORD_TYPE:
1698                                         record += sizeof(ATOM_LCD_MODE_CONTROL_CAP);
1699                                         break;
1700                                 case LCD_FAKE_EDID_PATCH_RECORD_TYPE:
1701                                         fake_edid_record = (ATOM_FAKE_EDID_PATCH_RECORD *)record;
1702                                         if (fake_edid_record->ucFakeEDIDLength) {
1703                                                 struct edid *edid;
1704                                                 int edid_size =
1705                                                         max((int)EDID_LENGTH, (int)fake_edid_record->ucFakeEDIDLength);
1706                                                 edid = kmalloc(edid_size, GFP_KERNEL);
1707                                                 if (edid) {
1708                                                         memcpy((u8 *)edid, (u8 *)&fake_edid_record->ucFakeEDIDString[0],
1709                                                                fake_edid_record->ucFakeEDIDLength);
1710
1711                                                         if (drm_edid_is_valid(edid)) {
1712                                                                 rdev->mode_info.bios_hardcoded_edid = edid;
1713                                                                 rdev->mode_info.bios_hardcoded_edid_size = edid_size;
1714                                                         } else
1715                                                                 kfree(edid);
1716                                                 }
1717                                         }
1718                                         record += fake_edid_record->ucFakeEDIDLength ?
1719                                                 fake_edid_record->ucFakeEDIDLength + 2 :
1720                                                 sizeof(ATOM_FAKE_EDID_PATCH_RECORD);
1721                                         break;
1722                                 case LCD_PANEL_RESOLUTION_RECORD_TYPE:
1723                                         panel_res_record = (ATOM_PANEL_RESOLUTION_PATCH_RECORD *)record;
1724                                         lvds->native_mode.width_mm = panel_res_record->usHSize;
1725                                         lvds->native_mode.height_mm = panel_res_record->usVSize;
1726                                         record += sizeof(ATOM_PANEL_RESOLUTION_PATCH_RECORD);
1727                                         break;
1728                                 default:
1729                                         DRM_ERROR("Bad LCD record %d\n", *record);
1730                                         bad_record = true;
1731                                         break;
1732                                 }
1733                                 if (bad_record)
1734                                         break;
1735                         }
1736                 }
1737         }
1738         return lvds;
1739 }
1740
1741 struct radeon_encoder_primary_dac *
1742 radeon_atombios_get_primary_dac_info(struct radeon_encoder *encoder)
1743 {
1744         struct drm_device *dev = encoder->base.dev;
1745         struct radeon_device *rdev = dev->dev_private;
1746         struct radeon_mode_info *mode_info = &rdev->mode_info;
1747         int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1748         uint16_t data_offset;
1749         struct _COMPASSIONATE_DATA *dac_info;
1750         uint8_t frev, crev;
1751         uint8_t bg, dac;
1752         struct radeon_encoder_primary_dac *p_dac = NULL;
1753
1754         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1755                                    &frev, &crev, &data_offset)) {
1756                 dac_info = (struct _COMPASSIONATE_DATA *)
1757                         (mode_info->atom_context->bios + data_offset);
1758
1759                 p_dac = kzalloc(sizeof(struct radeon_encoder_primary_dac), GFP_KERNEL);
1760
1761                 if (!p_dac)
1762                         return NULL;
1763
1764                 bg = dac_info->ucDAC1_BG_Adjustment;
1765                 dac = dac_info->ucDAC1_DAC_Adjustment;
1766                 p_dac->ps2_pdac_adj = (bg << 8) | (dac);
1767
1768         }
1769         return p_dac;
1770 }
1771
1772 bool radeon_atom_get_tv_timings(struct radeon_device *rdev, int index,
1773                                 struct drm_display_mode *mode)
1774 {
1775         struct radeon_mode_info *mode_info = &rdev->mode_info;
1776         ATOM_ANALOG_TV_INFO *tv_info;
1777         ATOM_ANALOG_TV_INFO_V1_2 *tv_info_v1_2;
1778         ATOM_DTD_FORMAT *dtd_timings;
1779         int data_index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1780         u8 frev, crev;
1781         u16 data_offset, misc;
1782
1783         if (!atom_parse_data_header(mode_info->atom_context, data_index, NULL,
1784                                     &frev, &crev, &data_offset))
1785                 return false;
1786
1787         switch (crev) {
1788         case 1:
1789                 tv_info = (ATOM_ANALOG_TV_INFO *)(mode_info->atom_context->bios + data_offset);
1790                 if (index >= MAX_SUPPORTED_TV_TIMING)
1791                         return false;
1792
1793                 mode->crtc_htotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Total);
1794                 mode->crtc_hdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Disp);
1795                 mode->crtc_hsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart);
1796                 mode->crtc_hsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart) +
1797                         le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncWidth);
1798
1799                 mode->crtc_vtotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Total);
1800                 mode->crtc_vdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Disp);
1801                 mode->crtc_vsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart);
1802                 mode->crtc_vsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart) +
1803                         le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncWidth);
1804
1805                 mode->flags = 0;
1806                 misc = le16_to_cpu(tv_info->aModeTimings[index].susModeMiscInfo.usAccess);
1807                 if (misc & ATOM_VSYNC_POLARITY)
1808                         mode->flags |= DRM_MODE_FLAG_NVSYNC;
1809                 if (misc & ATOM_HSYNC_POLARITY)
1810                         mode->flags |= DRM_MODE_FLAG_NHSYNC;
1811                 if (misc & ATOM_COMPOSITESYNC)
1812                         mode->flags |= DRM_MODE_FLAG_CSYNC;
1813                 if (misc & ATOM_INTERLACE)
1814                         mode->flags |= DRM_MODE_FLAG_INTERLACE;
1815                 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1816                         mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1817
1818                 mode->crtc_clock = mode->clock =
1819                         le16_to_cpu(tv_info->aModeTimings[index].usPixelClock) * 10;
1820
1821                 if (index == 1) {
1822                         /* PAL timings appear to have wrong values for totals */
1823                         mode->crtc_htotal -= 1;
1824                         mode->crtc_vtotal -= 1;
1825                 }
1826                 break;
1827         case 2:
1828                 tv_info_v1_2 = (ATOM_ANALOG_TV_INFO_V1_2 *)(mode_info->atom_context->bios + data_offset);
1829                 if (index >= MAX_SUPPORTED_TV_TIMING_V1_2)
1830                         return false;
1831
1832                 dtd_timings = &tv_info_v1_2->aModeTimings[index];
1833                 mode->crtc_htotal = le16_to_cpu(dtd_timings->usHActive) +
1834                         le16_to_cpu(dtd_timings->usHBlanking_Time);
1835                 mode->crtc_hdisplay = le16_to_cpu(dtd_timings->usHActive);
1836                 mode->crtc_hsync_start = le16_to_cpu(dtd_timings->usHActive) +
1837                         le16_to_cpu(dtd_timings->usHSyncOffset);
1838                 mode->crtc_hsync_end = mode->crtc_hsync_start +
1839                         le16_to_cpu(dtd_timings->usHSyncWidth);
1840
1841                 mode->crtc_vtotal = le16_to_cpu(dtd_timings->usVActive) +
1842                         le16_to_cpu(dtd_timings->usVBlanking_Time);
1843                 mode->crtc_vdisplay = le16_to_cpu(dtd_timings->usVActive);
1844                 mode->crtc_vsync_start = le16_to_cpu(dtd_timings->usVActive) +
1845                         le16_to_cpu(dtd_timings->usVSyncOffset);
1846                 mode->crtc_vsync_end = mode->crtc_vsync_start +
1847                         le16_to_cpu(dtd_timings->usVSyncWidth);
1848
1849                 mode->flags = 0;
1850                 misc = le16_to_cpu(dtd_timings->susModeMiscInfo.usAccess);
1851                 if (misc & ATOM_VSYNC_POLARITY)
1852                         mode->flags |= DRM_MODE_FLAG_NVSYNC;
1853                 if (misc & ATOM_HSYNC_POLARITY)
1854                         mode->flags |= DRM_MODE_FLAG_NHSYNC;
1855                 if (misc & ATOM_COMPOSITESYNC)
1856                         mode->flags |= DRM_MODE_FLAG_CSYNC;
1857                 if (misc & ATOM_INTERLACE)
1858                         mode->flags |= DRM_MODE_FLAG_INTERLACE;
1859                 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1860                         mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1861
1862                 mode->crtc_clock = mode->clock =
1863                         le16_to_cpu(dtd_timings->usPixClk) * 10;
1864                 break;
1865         }
1866         return true;
1867 }
1868
1869 enum radeon_tv_std
1870 radeon_atombios_get_tv_info(struct radeon_device *rdev)
1871 {
1872         struct radeon_mode_info *mode_info = &rdev->mode_info;
1873         int index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1874         uint16_t data_offset;
1875         uint8_t frev, crev;
1876         struct _ATOM_ANALOG_TV_INFO *tv_info;
1877         enum radeon_tv_std tv_std = TV_STD_NTSC;
1878
1879         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1880                                    &frev, &crev, &data_offset)) {
1881
1882                 tv_info = (struct _ATOM_ANALOG_TV_INFO *)
1883                         (mode_info->atom_context->bios + data_offset);
1884
1885                 switch (tv_info->ucTV_BootUpDefaultStandard) {
1886                 case ATOM_TV_NTSC:
1887                         tv_std = TV_STD_NTSC;
1888                         DRM_DEBUG_KMS("Default TV standard: NTSC\n");
1889                         break;
1890                 case ATOM_TV_NTSCJ:
1891                         tv_std = TV_STD_NTSC_J;
1892                         DRM_DEBUG_KMS("Default TV standard: NTSC-J\n");
1893                         break;
1894                 case ATOM_TV_PAL:
1895                         tv_std = TV_STD_PAL;
1896                         DRM_DEBUG_KMS("Default TV standard: PAL\n");
1897                         break;
1898                 case ATOM_TV_PALM:
1899                         tv_std = TV_STD_PAL_M;
1900                         DRM_DEBUG_KMS("Default TV standard: PAL-M\n");
1901                         break;
1902                 case ATOM_TV_PALN:
1903                         tv_std = TV_STD_PAL_N;
1904                         DRM_DEBUG_KMS("Default TV standard: PAL-N\n");
1905                         break;
1906                 case ATOM_TV_PALCN:
1907                         tv_std = TV_STD_PAL_CN;
1908                         DRM_DEBUG_KMS("Default TV standard: PAL-CN\n");
1909                         break;
1910                 case ATOM_TV_PAL60:
1911                         tv_std = TV_STD_PAL_60;
1912                         DRM_DEBUG_KMS("Default TV standard: PAL-60\n");
1913                         break;
1914                 case ATOM_TV_SECAM:
1915                         tv_std = TV_STD_SECAM;
1916                         DRM_DEBUG_KMS("Default TV standard: SECAM\n");
1917                         break;
1918                 default:
1919                         tv_std = TV_STD_NTSC;
1920                         DRM_DEBUG_KMS("Unknown TV standard; defaulting to NTSC\n");
1921                         break;
1922                 }
1923         }
1924         return tv_std;
1925 }
1926
1927 struct radeon_encoder_tv_dac *
1928 radeon_atombios_get_tv_dac_info(struct radeon_encoder *encoder)
1929 {
1930         struct drm_device *dev = encoder->base.dev;
1931         struct radeon_device *rdev = dev->dev_private;
1932         struct radeon_mode_info *mode_info = &rdev->mode_info;
1933         int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1934         uint16_t data_offset;
1935         struct _COMPASSIONATE_DATA *dac_info;
1936         uint8_t frev, crev;
1937         uint8_t bg, dac;
1938         struct radeon_encoder_tv_dac *tv_dac = NULL;
1939
1940         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1941                                    &frev, &crev, &data_offset)) {
1942
1943                 dac_info = (struct _COMPASSIONATE_DATA *)
1944                         (mode_info->atom_context->bios + data_offset);
1945
1946                 tv_dac = kzalloc(sizeof(struct radeon_encoder_tv_dac), GFP_KERNEL);
1947
1948                 if (!tv_dac)
1949                         return NULL;
1950
1951                 bg = dac_info->ucDAC2_CRT2_BG_Adjustment;
1952                 dac = dac_info->ucDAC2_CRT2_DAC_Adjustment;
1953                 tv_dac->ps2_tvdac_adj = (bg << 16) | (dac << 20);
1954
1955                 bg = dac_info->ucDAC2_PAL_BG_Adjustment;
1956                 dac = dac_info->ucDAC2_PAL_DAC_Adjustment;
1957                 tv_dac->pal_tvdac_adj = (bg << 16) | (dac << 20);
1958
1959                 bg = dac_info->ucDAC2_NTSC_BG_Adjustment;
1960                 dac = dac_info->ucDAC2_NTSC_DAC_Adjustment;
1961                 tv_dac->ntsc_tvdac_adj = (bg << 16) | (dac << 20);
1962
1963                 tv_dac->tv_std = radeon_atombios_get_tv_info(rdev);
1964         }
1965         return tv_dac;
1966 }
1967
1968 static const char *thermal_controller_names[] = {
1969         "NONE",
1970         "lm63",
1971         "adm1032",
1972         "adm1030",
1973         "max6649",
1974         "lm63", /* lm64 */
1975         "f75375",
1976         "asc7xxx",
1977 };
1978
1979 static const char *pp_lib_thermal_controller_names[] = {
1980         "NONE",
1981         "lm63",
1982         "adm1032",
1983         "adm1030",
1984         "max6649",
1985         "lm63", /* lm64 */
1986         "f75375",
1987         "RV6xx",
1988         "RV770",
1989         "adt7473",
1990         "NONE",
1991         "External GPIO",
1992         "Evergreen",
1993         "emc2103",
1994         "Sumo",
1995         "Northern Islands",
1996         "Southern Islands",
1997         "lm96163",
1998         "Sea Islands",
1999 };
2000
2001 union power_info {
2002         struct _ATOM_POWERPLAY_INFO info;
2003         struct _ATOM_POWERPLAY_INFO_V2 info_2;
2004         struct _ATOM_POWERPLAY_INFO_V3 info_3;
2005         struct _ATOM_PPLIB_POWERPLAYTABLE pplib;
2006         struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2;
2007         struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3;
2008 };
2009
2010 union pplib_clock_info {
2011         struct _ATOM_PPLIB_R600_CLOCK_INFO r600;
2012         struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780;
2013         struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen;
2014         struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo;
2015         struct _ATOM_PPLIB_SI_CLOCK_INFO si;
2016         struct _ATOM_PPLIB_CI_CLOCK_INFO ci;
2017 };
2018
2019 union pplib_power_state {
2020         struct _ATOM_PPLIB_STATE v1;
2021         struct _ATOM_PPLIB_STATE_V2 v2;
2022 };
2023
2024 static void radeon_atombios_parse_misc_flags_1_3(struct radeon_device *rdev,
2025                                                  int state_index,
2026                                                  u32 misc, u32 misc2)
2027 {
2028         rdev->pm.power_state[state_index].misc = misc;
2029         rdev->pm.power_state[state_index].misc2 = misc2;
2030         /* order matters! */
2031         if (misc & ATOM_PM_MISCINFO_POWER_SAVING_MODE)
2032                 rdev->pm.power_state[state_index].type =
2033                         POWER_STATE_TYPE_POWERSAVE;
2034         if (misc & ATOM_PM_MISCINFO_DEFAULT_DC_STATE_ENTRY_TRUE)
2035                 rdev->pm.power_state[state_index].type =
2036                         POWER_STATE_TYPE_BATTERY;
2037         if (misc & ATOM_PM_MISCINFO_DEFAULT_LOW_DC_STATE_ENTRY_TRUE)
2038                 rdev->pm.power_state[state_index].type =
2039                         POWER_STATE_TYPE_BATTERY;
2040         if (misc & ATOM_PM_MISCINFO_LOAD_BALANCE_EN)
2041                 rdev->pm.power_state[state_index].type =
2042                         POWER_STATE_TYPE_BALANCED;
2043         if (misc & ATOM_PM_MISCINFO_3D_ACCELERATION_EN) {
2044                 rdev->pm.power_state[state_index].type =
2045                         POWER_STATE_TYPE_PERFORMANCE;
2046                 rdev->pm.power_state[state_index].flags &=
2047                         ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2048         }
2049         if (misc2 & ATOM_PM_MISCINFO2_SYSTEM_AC_LITE_MODE)
2050                 rdev->pm.power_state[state_index].type =
2051                         POWER_STATE_TYPE_BALANCED;
2052         if (misc & ATOM_PM_MISCINFO_DRIVER_DEFAULT_MODE) {
2053                 rdev->pm.power_state[state_index].type =
2054                         POWER_STATE_TYPE_DEFAULT;
2055                 rdev->pm.default_power_state_index = state_index;
2056                 rdev->pm.power_state[state_index].default_clock_mode =
2057                         &rdev->pm.power_state[state_index].clock_info[0];
2058         } else if (state_index == 0) {
2059                 rdev->pm.power_state[state_index].clock_info[0].flags |=
2060                         RADEON_PM_MODE_NO_DISPLAY;
2061         }
2062 }
2063
2064 static int radeon_atombios_parse_power_table_1_3(struct radeon_device *rdev)
2065 {
2066         struct radeon_mode_info *mode_info = &rdev->mode_info;
2067         u32 misc, misc2 = 0;
2068         int num_modes = 0, i;
2069         int state_index = 0;
2070         struct radeon_i2c_bus_rec i2c_bus;
2071         union power_info *power_info;
2072         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2073         u16 data_offset;
2074         u8 frev, crev;
2075
2076         if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2077                                    &frev, &crev, &data_offset))
2078                 return state_index;
2079         power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2080
2081         /* add the i2c bus for thermal/fan chip */
2082         if ((power_info->info.ucOverdriveThermalController > 0) &&
2083             (power_info->info.ucOverdriveThermalController < ARRAY_SIZE(thermal_controller_names))) {
2084                 DRM_INFO("Possible %s thermal controller at 0x%02x\n",
2085                          thermal_controller_names[power_info->info.ucOverdriveThermalController],
2086                          power_info->info.ucOverdriveControllerAddress >> 1);
2087                 i2c_bus = radeon_lookup_i2c_gpio(rdev, power_info->info.ucOverdriveI2cLine);
2088                 rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
2089                 if (rdev->pm.i2c_bus) {
2090                         struct i2c_board_info info = { };
2091                         const char *name = thermal_controller_names[power_info->info.
2092                                                                     ucOverdriveThermalController];
2093                         info.addr = power_info->info.ucOverdriveControllerAddress >> 1;
2094                         strlcpy(info.type, name, sizeof(info.type));
2095                         i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
2096                 }
2097         }
2098         num_modes = power_info->info.ucNumOfPowerModeEntries;
2099         if (num_modes > ATOM_MAX_NUMBEROF_POWER_BLOCK)
2100                 num_modes = ATOM_MAX_NUMBEROF_POWER_BLOCK;
2101         if (num_modes == 0)
2102                 return state_index;
2103         rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) * num_modes, GFP_KERNEL);
2104         if (!rdev->pm.power_state)
2105                 return state_index;
2106         /* last mode is usually default, array is low to high */
2107         for (i = 0; i < num_modes; i++) {
2108                 rdev->pm.power_state[state_index].clock_info =
2109                         kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL);
2110                 if (!rdev->pm.power_state[state_index].clock_info)
2111                         return state_index;
2112                 rdev->pm.power_state[state_index].num_clock_modes = 1;
2113                 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2114                 switch (frev) {
2115                 case 1:
2116                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2117                                 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usMemoryClock);
2118                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2119                                 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usEngineClock);
2120                         /* skip invalid modes */
2121                         if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2122                             (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2123                                 continue;
2124                         rdev->pm.power_state[state_index].pcie_lanes =
2125                                 power_info->info.asPowerPlayInfo[i].ucNumPciELanes;
2126                         misc = le32_to_cpu(power_info->info.asPowerPlayInfo[i].ulMiscInfo);
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_atombios_lookup_gpio(rdev,
2133                                                            power_info->info.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.asPowerPlayInfo[i].ucVoltageDropIndex;
2145                         }
2146                         rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2147                         radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, 0);
2148                         state_index++;
2149                         break;
2150                 case 2:
2151                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2152                                 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMemoryClock);
2153                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2154                                 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulEngineClock);
2155                         /* skip invalid modes */
2156                         if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2157                             (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2158                                 continue;
2159                         rdev->pm.power_state[state_index].pcie_lanes =
2160                                 power_info->info_2.asPowerPlayInfo[i].ucNumPciELanes;
2161                         misc = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo);
2162                         misc2 = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo2);
2163                         if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2164                             (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2165                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2166                                         VOLTAGE_GPIO;
2167                                 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2168                                         radeon_atombios_lookup_gpio(rdev,
2169                                                            power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex);
2170                                 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2171                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2172                                                 true;
2173                                 else
2174                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2175                                                 false;
2176                         } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2177                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2178                                         VOLTAGE_VDDC;
2179                                 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2180                                         power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex;
2181                         }
2182                         rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2183                         radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2184                         state_index++;
2185                         break;
2186                 case 3:
2187                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2188                                 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMemoryClock);
2189                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2190                                 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulEngineClock);
2191                         /* skip invalid modes */
2192                         if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2193                             (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2194                                 continue;
2195                         rdev->pm.power_state[state_index].pcie_lanes =
2196                                 power_info->info_3.asPowerPlayInfo[i].ucNumPciELanes;
2197                         misc = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo);
2198                         misc2 = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo2);
2199                         if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2200                             (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2201                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2202                                         VOLTAGE_GPIO;
2203                                 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2204                                         radeon_atombios_lookup_gpio(rdev,
2205                                                            power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex);
2206                                 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2207                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2208                                                 true;
2209                                 else
2210                                         rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2211                                                 false;
2212                         } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2213                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2214                                         VOLTAGE_VDDC;
2215                                 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2216                                         power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex;
2217                                 if (misc2 & ATOM_PM_MISCINFO2_VDDCI_DYNAMIC_VOLTAGE_EN) {
2218                                         rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_enabled =
2219                                                 true;
2220                                         rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_id =
2221                                                 power_info->info_3.asPowerPlayInfo[i].ucVDDCI_VoltageDropIndex;
2222                                 }
2223                         }
2224                         rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2225                         radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2226                         state_index++;
2227                         break;
2228                 }
2229         }
2230         /* last mode is usually default */
2231         if (rdev->pm.default_power_state_index == -1) {
2232                 rdev->pm.power_state[state_index - 1].type =
2233                         POWER_STATE_TYPE_DEFAULT;
2234                 rdev->pm.default_power_state_index = state_index - 1;
2235                 rdev->pm.power_state[state_index - 1].default_clock_mode =
2236                         &rdev->pm.power_state[state_index - 1].clock_info[0];
2237                 rdev->pm.power_state[state_index].flags &=
2238                         ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2239                 rdev->pm.power_state[state_index].misc = 0;
2240                 rdev->pm.power_state[state_index].misc2 = 0;
2241         }
2242         return state_index;
2243 }
2244
2245 static void radeon_atombios_add_pplib_thermal_controller(struct radeon_device *rdev,
2246                                                          ATOM_PPLIB_THERMALCONTROLLER *controller)
2247 {
2248         struct radeon_i2c_bus_rec i2c_bus;
2249
2250         /* add the i2c bus for thermal/fan chip */
2251         if (controller->ucType > 0) {
2252                 if (controller->ucFanParameters & ATOM_PP_FANPARAMETERS_NOFAN)
2253                         rdev->pm.no_fan = true;
2254                 rdev->pm.fan_pulses_per_revolution =
2255                         controller->ucFanParameters & ATOM_PP_FANPARAMETERS_TACHOMETER_PULSES_PER_REVOLUTION_MASK;
2256                 if (rdev->pm.fan_pulses_per_revolution) {
2257                         rdev->pm.fan_min_rpm = controller->ucFanMinRPM;
2258                         rdev->pm.fan_max_rpm = controller->ucFanMaxRPM;
2259                 }
2260                 if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV6xx) {
2261                         DRM_INFO("Internal thermal controller %s fan control\n",
2262                                  (controller->ucFanParameters &
2263                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2264                         rdev->pm.int_thermal_type = THERMAL_TYPE_RV6XX;
2265                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV770) {
2266                         DRM_INFO("Internal thermal controller %s fan control\n",
2267                                  (controller->ucFanParameters &
2268                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2269                         rdev->pm.int_thermal_type = THERMAL_TYPE_RV770;
2270                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_EVERGREEN) {
2271                         DRM_INFO("Internal thermal controller %s fan control\n",
2272                                  (controller->ucFanParameters &
2273                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2274                         rdev->pm.int_thermal_type = THERMAL_TYPE_EVERGREEN;
2275                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_SUMO) {
2276                         DRM_INFO("Internal thermal controller %s fan control\n",
2277                                  (controller->ucFanParameters &
2278                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2279                         rdev->pm.int_thermal_type = THERMAL_TYPE_SUMO;
2280                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_NISLANDS) {
2281                         DRM_INFO("Internal thermal controller %s fan control\n",
2282                                  (controller->ucFanParameters &
2283                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2284                         rdev->pm.int_thermal_type = THERMAL_TYPE_NI;
2285                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_SISLANDS) {
2286                         DRM_INFO("Internal thermal controller %s fan control\n",
2287                                  (controller->ucFanParameters &
2288                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2289                         rdev->pm.int_thermal_type = THERMAL_TYPE_SI;
2290                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_CISLANDS) {
2291                         DRM_INFO("Internal thermal controller %s fan control\n",
2292                                  (controller->ucFanParameters &
2293                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2294                         rdev->pm.int_thermal_type = THERMAL_TYPE_CI;
2295                 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_KAVERI) {
2296                         DRM_INFO("Internal thermal controller %s fan control\n",
2297                                  (controller->ucFanParameters &
2298                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2299                         rdev->pm.int_thermal_type = THERMAL_TYPE_KV;
2300                 } else if (controller->ucType ==
2301                            ATOM_PP_THERMALCONTROLLER_EXTERNAL_GPIO) {
2302                         DRM_INFO("External GPIO thermal controller %s fan control\n",
2303                                  (controller->ucFanParameters &
2304                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2305                         rdev->pm.int_thermal_type = THERMAL_TYPE_EXTERNAL_GPIO;
2306                 } else if (controller->ucType ==
2307                            ATOM_PP_THERMALCONTROLLER_ADT7473_WITH_INTERNAL) {
2308                         DRM_INFO("ADT7473 with internal thermal controller %s fan control\n",
2309                                  (controller->ucFanParameters &
2310                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2311                         rdev->pm.int_thermal_type = THERMAL_TYPE_ADT7473_WITH_INTERNAL;
2312                 } else if (controller->ucType ==
2313                            ATOM_PP_THERMALCONTROLLER_EMC2103_WITH_INTERNAL) {
2314                         DRM_INFO("EMC2103 with internal thermal controller %s fan control\n",
2315                                  (controller->ucFanParameters &
2316                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2317                         rdev->pm.int_thermal_type = THERMAL_TYPE_EMC2103_WITH_INTERNAL;
2318                 } else if (controller->ucType < ARRAY_SIZE(pp_lib_thermal_controller_names)) {
2319                         DRM_INFO("Possible %s thermal controller at 0x%02x %s fan control\n",
2320                                  pp_lib_thermal_controller_names[controller->ucType],
2321                                  controller->ucI2cAddress >> 1,
2322                                  (controller->ucFanParameters &
2323                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2324                         rdev->pm.int_thermal_type = THERMAL_TYPE_EXTERNAL;
2325                         i2c_bus = radeon_lookup_i2c_gpio(rdev, controller->ucI2cLine);
2326                         rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
2327                         if (rdev->pm.i2c_bus) {
2328                                 struct i2c_board_info info = { };
2329                                 const char *name = pp_lib_thermal_controller_names[controller->ucType];
2330                                 info.addr = controller->ucI2cAddress >> 1;
2331                                 strlcpy(info.type, name, sizeof(info.type));
2332                                 i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
2333                         }
2334                 } else {
2335                         DRM_INFO("Unknown thermal controller type %d at 0x%02x %s fan control\n",
2336                                  controller->ucType,
2337                                  controller->ucI2cAddress >> 1,
2338                                  (controller->ucFanParameters &
2339                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2340                 }
2341         }
2342 }
2343
2344 void radeon_atombios_get_default_voltages(struct radeon_device *rdev,
2345                                           u16 *vddc, u16 *vddci, u16 *mvdd)
2346 {
2347         struct radeon_mode_info *mode_info = &rdev->mode_info;
2348         int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
2349         u8 frev, crev;
2350         u16 data_offset;
2351         union firmware_info *firmware_info;
2352
2353         *vddc = 0;
2354         *vddci = 0;
2355         *mvdd = 0;
2356
2357         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2358                                    &frev, &crev, &data_offset)) {
2359                 firmware_info =
2360                         (union firmware_info *)(mode_info->atom_context->bios +
2361                                                 data_offset);
2362                 *vddc = le16_to_cpu(firmware_info->info_14.usBootUpVDDCVoltage);
2363                 if ((frev == 2) && (crev >= 2)) {
2364                         *vddci = le16_to_cpu(firmware_info->info_22.usBootUpVDDCIVoltage);
2365                         *mvdd = le16_to_cpu(firmware_info->info_22.usBootUpMVDDCVoltage);
2366                 }
2367         }
2368 }
2369
2370 static void radeon_atombios_parse_pplib_non_clock_info(struct radeon_device *rdev,
2371                                                        int state_index, int mode_index,
2372                                                        struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info)
2373 {
2374         int j;
2375         u32 misc = le32_to_cpu(non_clock_info->ulCapsAndSettings);
2376         u32 misc2 = le16_to_cpu(non_clock_info->usClassification);
2377         u16 vddc, vddci, mvdd;
2378
2379         radeon_atombios_get_default_voltages(rdev, &vddc, &vddci, &mvdd);
2380
2381         rdev->pm.power_state[state_index].misc = misc;
2382         rdev->pm.power_state[state_index].misc2 = misc2;
2383         rdev->pm.power_state[state_index].pcie_lanes =
2384                 ((misc & ATOM_PPLIB_PCIE_LINK_WIDTH_MASK) >>
2385                  ATOM_PPLIB_PCIE_LINK_WIDTH_SHIFT) + 1;
2386         switch (misc2 & ATOM_PPLIB_CLASSIFICATION_UI_MASK) {
2387         case ATOM_PPLIB_CLASSIFICATION_UI_BATTERY:
2388                 rdev->pm.power_state[state_index].type =
2389                         POWER_STATE_TYPE_BATTERY;
2390                 break;
2391         case ATOM_PPLIB_CLASSIFICATION_UI_BALANCED:
2392                 rdev->pm.power_state[state_index].type =
2393                         POWER_STATE_TYPE_BALANCED;
2394                 break;
2395         case ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE:
2396                 rdev->pm.power_state[state_index].type =
2397                         POWER_STATE_TYPE_PERFORMANCE;
2398                 break;
2399         case ATOM_PPLIB_CLASSIFICATION_UI_NONE:
2400                 if (misc2 & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE)
2401                         rdev->pm.power_state[state_index].type =
2402                                 POWER_STATE_TYPE_PERFORMANCE;
2403                 break;
2404         }
2405         rdev->pm.power_state[state_index].flags = 0;
2406         if (misc & ATOM_PPLIB_SINGLE_DISPLAY_ONLY)
2407                 rdev->pm.power_state[state_index].flags |=
2408                         RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2409         if (misc2 & ATOM_PPLIB_CLASSIFICATION_BOOT) {
2410                 rdev->pm.power_state[state_index].type =
2411                         POWER_STATE_TYPE_DEFAULT;
2412                 rdev->pm.default_power_state_index = state_index;
2413                 rdev->pm.power_state[state_index].default_clock_mode =
2414                         &rdev->pm.power_state[state_index].clock_info[mode_index - 1];
2415                 if ((rdev->family >= CHIP_BARTS) && !(rdev->flags & RADEON_IS_IGP)) {
2416                         /* NI chips post without MC ucode, so default clocks are strobe mode only */
2417                         rdev->pm.default_sclk = rdev->pm.power_state[state_index].clock_info[0].sclk;
2418                         rdev->pm.default_mclk = rdev->pm.power_state[state_index].clock_info[0].mclk;
2419                         rdev->pm.default_vddc = rdev->pm.power_state[state_index].clock_info[0].voltage.voltage;
2420                         rdev->pm.default_vddci = rdev->pm.power_state[state_index].clock_info[0].voltage.vddci;
2421                 } else {
2422                         u16 max_vddci = 0;
2423
2424                         if (ASIC_IS_DCE4(rdev))
2425                                 radeon_atom_get_max_voltage(rdev,
2426                                                             SET_VOLTAGE_TYPE_ASIC_VDDCI,
2427                                                             &max_vddci);
2428                         /* patch the table values with the default sclk/mclk from firmware info */
2429                         for (j = 0; j < mode_index; j++) {
2430                                 rdev->pm.power_state[state_index].clock_info[j].mclk =
2431                                         rdev->clock.default_mclk;
2432                                 rdev->pm.power_state[state_index].clock_info[j].sclk =
2433                                         rdev->clock.default_sclk;
2434                                 if (vddc)
2435                                         rdev->pm.power_state[state_index].clock_info[j].voltage.voltage =
2436                                                 vddc;
2437                                 if (max_vddci)
2438                                         rdev->pm.power_state[state_index].clock_info[j].voltage.vddci =
2439                                                 max_vddci;
2440                         }
2441                 }
2442         }
2443 }
2444
2445 static bool radeon_atombios_parse_pplib_clock_info(struct radeon_device *rdev,
2446                                                    int state_index, int mode_index,
2447                                                    union pplib_clock_info *clock_info)
2448 {
2449         u32 sclk, mclk;
2450         u16 vddc;
2451
2452         if (rdev->flags & RADEON_IS_IGP) {
2453                 if (rdev->family >= CHIP_PALM) {
2454                         sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow);
2455                         sclk |= clock_info->sumo.ucEngineClockHigh << 16;
2456                         rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2457                 } else {
2458                         sclk = le16_to_cpu(clock_info->rs780.usLowEngineClockLow);
2459                         sclk |= clock_info->rs780.ucLowEngineClockHigh << 16;
2460                         rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2461                 }
2462         } else if (rdev->family >= CHIP_BONAIRE) {
2463                 sclk = le16_to_cpu(clock_info->ci.usEngineClockLow);
2464                 sclk |= clock_info->ci.ucEngineClockHigh << 16;
2465                 mclk = le16_to_cpu(clock_info->ci.usMemoryClockLow);
2466                 mclk |= clock_info->ci.ucMemoryClockHigh << 16;
2467                 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2468                 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2469                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2470                         VOLTAGE_NONE;
2471         } else if (rdev->family >= CHIP_TAHITI) {
2472                 sclk = le16_to_cpu(clock_info->si.usEngineClockLow);
2473                 sclk |= clock_info->si.ucEngineClockHigh << 16;
2474                 mclk = le16_to_cpu(clock_info->si.usMemoryClockLow);
2475                 mclk |= clock_info->si.ucMemoryClockHigh << 16;
2476                 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2477                 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2478                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2479                         VOLTAGE_SW;
2480                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2481                         le16_to_cpu(clock_info->si.usVDDC);
2482                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.vddci =
2483                         le16_to_cpu(clock_info->si.usVDDCI);
2484         } else if (rdev->family >= CHIP_CEDAR) {
2485                 sclk = le16_to_cpu(clock_info->evergreen.usEngineClockLow);
2486                 sclk |= clock_info->evergreen.ucEngineClockHigh << 16;
2487                 mclk = le16_to_cpu(clock_info->evergreen.usMemoryClockLow);
2488                 mclk |= clock_info->evergreen.ucMemoryClockHigh << 16;
2489                 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2490                 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2491                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2492                         VOLTAGE_SW;
2493                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2494                         le16_to_cpu(clock_info->evergreen.usVDDC);
2495                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.vddci =
2496                         le16_to_cpu(clock_info->evergreen.usVDDCI);
2497         } else {
2498                 sclk = le16_to_cpu(clock_info->r600.usEngineClockLow);
2499                 sclk |= clock_info->r600.ucEngineClockHigh << 16;
2500                 mclk = le16_to_cpu(clock_info->r600.usMemoryClockLow);
2501                 mclk |= clock_info->r600.ucMemoryClockHigh << 16;
2502                 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2503                 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2504                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2505                         VOLTAGE_SW;
2506                 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2507                         le16_to_cpu(clock_info->r600.usVDDC);
2508         }
2509
2510         /* patch up vddc if necessary */
2511         switch (rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage) {
2512         case ATOM_VIRTUAL_VOLTAGE_ID0:
2513         case ATOM_VIRTUAL_VOLTAGE_ID1:
2514         case ATOM_VIRTUAL_VOLTAGE_ID2:
2515         case ATOM_VIRTUAL_VOLTAGE_ID3:
2516         case ATOM_VIRTUAL_VOLTAGE_ID4:
2517         case ATOM_VIRTUAL_VOLTAGE_ID5:
2518         case ATOM_VIRTUAL_VOLTAGE_ID6:
2519         case ATOM_VIRTUAL_VOLTAGE_ID7:
2520                 if (radeon_atom_get_max_vddc(rdev, VOLTAGE_TYPE_VDDC,
2521                                              rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage,
2522                                              &vddc) == 0)
2523                         rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage = vddc;
2524                 break;
2525         default:
2526                 break;
2527         }
2528
2529         if (rdev->flags & RADEON_IS_IGP) {
2530                 /* skip invalid modes */
2531                 if (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0)
2532                         return false;
2533         } else {
2534                 /* skip invalid modes */
2535                 if ((rdev->pm.power_state[state_index].clock_info[mode_index].mclk == 0) ||
2536                     (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0))
2537                         return false;
2538         }
2539         return true;
2540 }
2541
2542 static int radeon_atombios_parse_power_table_4_5(struct radeon_device *rdev)
2543 {
2544         struct radeon_mode_info *mode_info = &rdev->mode_info;
2545         struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2546         union pplib_power_state *power_state;
2547         int i, j;
2548         int state_index = 0, mode_index = 0;
2549         union pplib_clock_info *clock_info;
2550         bool valid;
2551         union power_info *power_info;
2552         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2553         u16 data_offset;
2554         u8 frev, crev;
2555
2556         if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2557                                    &frev, &crev, &data_offset))
2558                 return state_index;
2559         power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2560
2561         radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2562         if (power_info->pplib.ucNumStates == 0)
2563                 return state_index;
2564         rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) *
2565                                        power_info->pplib.ucNumStates, GFP_KERNEL);
2566         if (!rdev->pm.power_state)
2567                 return state_index;
2568         /* first mode is usually default, followed by low to high */
2569         for (i = 0; i < power_info->pplib.ucNumStates; i++) {
2570                 mode_index = 0;
2571                 power_state = (union pplib_power_state *)
2572                         (mode_info->atom_context->bios + data_offset +
2573                          le16_to_cpu(power_info->pplib.usStateArrayOffset) +
2574                          i * power_info->pplib.ucStateEntrySize);
2575                 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2576                         (mode_info->atom_context->bios + data_offset +
2577                          le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset) +
2578                          (power_state->v1.ucNonClockStateIndex *
2579                           power_info->pplib.ucNonClockSize));
2580                 rdev->pm.power_state[i].clock_info = kzalloc(sizeof(struct radeon_pm_clock_info) *
2581                                                              ((power_info->pplib.ucStateEntrySize - 1) ?
2582                                                               (power_info->pplib.ucStateEntrySize - 1) : 1),
2583                                                              GFP_KERNEL);
2584                 if (!rdev->pm.power_state[i].clock_info)
2585                         return state_index;
2586                 if (power_info->pplib.ucStateEntrySize - 1) {
2587                         for (j = 0; j < (power_info->pplib.ucStateEntrySize - 1); j++) {
2588                                 clock_info = (union pplib_clock_info *)
2589                                         (mode_info->atom_context->bios + data_offset +
2590                                          le16_to_cpu(power_info->pplib.usClockInfoArrayOffset) +
2591                                          (power_state->v1.ucClockStateIndices[j] *
2592                                           power_info->pplib.ucClockInfoSize));
2593                                 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2594                                                                                state_index, mode_index,
2595                                                                                clock_info);
2596                                 if (valid)
2597                                         mode_index++;
2598                         }
2599                 } else {
2600                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2601                                 rdev->clock.default_mclk;
2602                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2603                                 rdev->clock.default_sclk;
2604                         mode_index++;
2605                 }
2606                 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2607                 if (mode_index) {
2608                         radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2609                                                                    non_clock_info);
2610                         state_index++;
2611                 }
2612         }
2613         /* if multiple clock modes, mark the lowest as no display */
2614         for (i = 0; i < state_index; i++) {
2615                 if (rdev->pm.power_state[i].num_clock_modes > 1)
2616                         rdev->pm.power_state[i].clock_info[0].flags |=
2617                                 RADEON_PM_MODE_NO_DISPLAY;
2618         }
2619         /* first mode is usually default */
2620         if (rdev->pm.default_power_state_index == -1) {
2621                 rdev->pm.power_state[0].type =
2622                         POWER_STATE_TYPE_DEFAULT;
2623                 rdev->pm.default_power_state_index = 0;
2624                 rdev->pm.power_state[0].default_clock_mode =
2625                         &rdev->pm.power_state[0].clock_info[0];
2626         }
2627         return state_index;
2628 }
2629
2630 static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
2631 {
2632         struct radeon_mode_info *mode_info = &rdev->mode_info;
2633         struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2634         union pplib_power_state *power_state;
2635         int i, j, non_clock_array_index, clock_array_index;
2636         int state_index = 0, mode_index = 0;
2637         union pplib_clock_info *clock_info;
2638         struct _StateArray *state_array;
2639         struct _ClockInfoArray *clock_info_array;
2640         struct _NonClockInfoArray *non_clock_info_array;
2641         bool valid;
2642         union power_info *power_info;
2643         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2644         u16 data_offset;
2645         u8 frev, crev;
2646         u8 *power_state_offset;
2647
2648         if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2649                                    &frev, &crev, &data_offset))
2650                 return state_index;
2651         power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2652
2653         radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2654         state_array = (struct _StateArray *)
2655                 (mode_info->atom_context->bios + data_offset +
2656                  le16_to_cpu(power_info->pplib.usStateArrayOffset));
2657         clock_info_array = (struct _ClockInfoArray *)
2658                 (mode_info->atom_context->bios + data_offset +
2659                  le16_to_cpu(power_info->pplib.usClockInfoArrayOffset));
2660         non_clock_info_array = (struct _NonClockInfoArray *)
2661                 (mode_info->atom_context->bios + data_offset +
2662                  le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
2663         if (state_array->ucNumEntries == 0)
2664                 return state_index;
2665         rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) *
2666                                        state_array->ucNumEntries, GFP_KERNEL);
2667         if (!rdev->pm.power_state)
2668                 return state_index;
2669         power_state_offset = (u8 *)state_array->states;
2670         for (i = 0; i < state_array->ucNumEntries; i++) {
2671                 mode_index = 0;
2672                 power_state = (union pplib_power_state *)power_state_offset;
2673                 non_clock_array_index = power_state->v2.nonClockInfoIndex;
2674                 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2675                         &non_clock_info_array->nonClockInfo[non_clock_array_index];
2676                 rdev->pm.power_state[i].clock_info = kzalloc(sizeof(struct radeon_pm_clock_info) *
2677                                                              (power_state->v2.ucNumDPMLevels ?
2678                                                               power_state->v2.ucNumDPMLevels : 1),
2679                                                              GFP_KERNEL);
2680                 if (!rdev->pm.power_state[i].clock_info)
2681                         return state_index;
2682                 if (power_state->v2.ucNumDPMLevels) {
2683                         for (j = 0; j < power_state->v2.ucNumDPMLevels; j++) {
2684                                 clock_array_index = power_state->v2.clockInfoIndex[j];
2685                                 clock_info = (union pplib_clock_info *)
2686                                         &clock_info_array->clockInfo[clock_array_index * clock_info_array->ucEntrySize];
2687                                 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2688                                                                                state_index, mode_index,
2689                                                                                clock_info);
2690                                 if (valid)
2691                                         mode_index++;
2692                         }
2693                 } else {
2694                         rdev->pm.power_state[state_index].clock_info[0].mclk =
2695                                 rdev->clock.default_mclk;
2696                         rdev->pm.power_state[state_index].clock_info[0].sclk =
2697                                 rdev->clock.default_sclk;
2698                         mode_index++;
2699                 }
2700                 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2701                 if (mode_index) {
2702                         radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2703                                                                    non_clock_info);
2704                         state_index++;
2705                 }
2706                 power_state_offset += 2 + power_state->v2.ucNumDPMLevels;
2707         }
2708         /* if multiple clock modes, mark the lowest as no display */
2709         for (i = 0; i < state_index; i++) {
2710                 if (rdev->pm.power_state[i].num_clock_modes > 1)
2711                         rdev->pm.power_state[i].clock_info[0].flags |=
2712                                 RADEON_PM_MODE_NO_DISPLAY;
2713         }
2714         /* first mode is usually default */
2715         if (rdev->pm.default_power_state_index == -1) {
2716                 rdev->pm.power_state[0].type =
2717                         POWER_STATE_TYPE_DEFAULT;
2718                 rdev->pm.default_power_state_index = 0;
2719                 rdev->pm.power_state[0].default_clock_mode =
2720                         &rdev->pm.power_state[0].clock_info[0];
2721         }
2722         return state_index;
2723 }
2724
2725 void radeon_atombios_get_power_modes(struct radeon_device *rdev)
2726 {
2727         struct radeon_mode_info *mode_info = &rdev->mode_info;
2728         int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2729         u16 data_offset;
2730         u8 frev, crev;
2731         int state_index = 0;
2732
2733         rdev->pm.default_power_state_index = -1;
2734
2735         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2736                                    &frev, &crev, &data_offset)) {
2737                 switch (frev) {
2738                 case 1:
2739                 case 2:
2740                 case 3:
2741                         state_index = radeon_atombios_parse_power_table_1_3(rdev);
2742                         break;
2743                 case 4:
2744                 case 5:
2745                         state_index = radeon_atombios_parse_power_table_4_5(rdev);
2746                         break;
2747                 case 6:
2748                         state_index = radeon_atombios_parse_power_table_6(rdev);
2749                         break;
2750                 default:
2751                         break;
2752                 }
2753         }
2754
2755         if (state_index == 0) {
2756                 rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state), GFP_KERNEL);
2757                 if (rdev->pm.power_state) {
2758                         rdev->pm.power_state[0].clock_info =
2759                                 kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL);
2760                         if (rdev->pm.power_state[0].clock_info) {
2761                                 /* add the default mode */
2762                                 rdev->pm.power_state[state_index].type =
2763                                         POWER_STATE_TYPE_DEFAULT;
2764                                 rdev->pm.power_state[state_index].num_clock_modes = 1;
2765                                 rdev->pm.power_state[state_index].clock_info[0].mclk = rdev->clock.default_mclk;
2766                                 rdev->pm.power_state[state_index].clock_info[0].sclk = rdev->clock.default_sclk;
2767                                 rdev->pm.power_state[state_index].default_clock_mode =
2768                                         &rdev->pm.power_state[state_index].clock_info[0];
2769                                 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2770                                 rdev->pm.power_state[state_index].pcie_lanes = 16;
2771                                 rdev->pm.default_power_state_index = state_index;
2772                                 rdev->pm.power_state[state_index].flags = 0;
2773                                 state_index++;
2774                         }
2775                 }
2776         }
2777
2778         rdev->pm.num_power_states = state_index;
2779
2780         rdev->pm.current_power_state_index = rdev->pm.default_power_state_index;
2781         rdev->pm.current_clock_mode_index = 0;
2782         if (rdev->pm.default_power_state_index >= 0)
2783                 rdev->pm.current_vddc =
2784                         rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.voltage;
2785         else
2786                 rdev->pm.current_vddc = 0;
2787 }
2788
2789 union get_clock_dividers {
2790         struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS v1;
2791         struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2 v2;
2792         struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V3 v3;
2793         struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 v4;
2794         struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V5 v5;
2795         struct _COMPUTE_GPU_CLOCK_INPUT_PARAMETERS_V1_6 v6_in;
2796         struct _COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_6 v6_out;
2797 };
2798
2799 int radeon_atom_get_clock_dividers(struct radeon_device *rdev,
2800                                    u8 clock_type,
2801                                    u32 clock,
2802                                    bool strobe_mode,
2803                                    struct atom_clock_dividers *dividers)
2804 {
2805         union get_clock_dividers args;
2806         int index = GetIndexIntoMasterTable(COMMAND, ComputeMemoryEnginePLL);
2807         u8 frev, crev;
2808
2809         memset(&args, 0, sizeof(args));
2810         memset(dividers, 0, sizeof(struct atom_clock_dividers));
2811
2812         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2813                 return -EINVAL;
2814
2815         switch (crev) {
2816         case 1:
2817                 /* r4xx, r5xx */
2818                 args.v1.ucAction = clock_type;
2819                 args.v1.ulClock = cpu_to_le32(clock);   /* 10 khz */
2820
2821                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2822
2823                 dividers->post_div = args.v1.ucPostDiv;
2824                 dividers->fb_div = args.v1.ucFbDiv;
2825                 dividers->enable_post_div = true;
2826                 break;
2827         case 2:
2828         case 3:
2829         case 5:
2830                 /* r6xx, r7xx, evergreen, ni, si */
2831                 if (rdev->family <= CHIP_RV770) {
2832                         args.v2.ucAction = clock_type;
2833                         args.v2.ulClock = cpu_to_le32(clock);   /* 10 khz */
2834
2835                         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2836
2837                         dividers->post_div = args.v2.ucPostDiv;
2838                         dividers->fb_div = le16_to_cpu(args.v2.usFbDiv);
2839                         dividers->ref_div = args.v2.ucAction;
2840                         if (rdev->family == CHIP_RV770) {
2841                                 dividers->enable_post_div = (le32_to_cpu(args.v2.ulClock) & (1 << 24)) ?
2842                                         true : false;
2843                                 dividers->vco_mode = (le32_to_cpu(args.v2.ulClock) & (1 << 25)) ? 1 : 0;
2844                         } else
2845                                 dividers->enable_post_div = (dividers->fb_div & 1) ? true : false;
2846                 } else {
2847                         if (clock_type == COMPUTE_ENGINE_PLL_PARAM) {
2848                                 args.v3.ulClockParams = cpu_to_le32((clock_type << 24) | clock);
2849
2850                                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2851
2852                                 dividers->post_div = args.v3.ucPostDiv;
2853                                 dividers->enable_post_div = (args.v3.ucCntlFlag &
2854                                                              ATOM_PLL_CNTL_FLAG_PLL_POST_DIV_EN) ? true : false;
2855                                 dividers->enable_dithen = (args.v3.ucCntlFlag &
2856                                                            ATOM_PLL_CNTL_FLAG_FRACTION_DISABLE) ? false : true;
2857                                 dividers->whole_fb_div = le16_to_cpu(args.v3.ulFbDiv.usFbDiv);
2858                                 dividers->frac_fb_div = le16_to_cpu(args.v3.ulFbDiv.usFbDivFrac);
2859                                 dividers->ref_div = args.v3.ucRefDiv;
2860                                 dividers->vco_mode = (args.v3.ucCntlFlag &
2861                                                       ATOM_PLL_CNTL_FLAG_MPLL_VCO_MODE) ? 1 : 0;
2862                         } else {
2863                                 /* for SI we use ComputeMemoryClockParam for memory plls */
2864                                 if (rdev->family >= CHIP_TAHITI)
2865                                         return -EINVAL;
2866                                 args.v5.ulClockParams = cpu_to_le32((clock_type << 24) | clock);
2867                                 if (strobe_mode)
2868                                         args.v5.ucInputFlag = ATOM_PLL_INPUT_FLAG_PLL_STROBE_MODE_EN;
2869
2870                                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2871
2872                                 dividers->post_div = args.v5.ucPostDiv;
2873                                 dividers->enable_post_div = (args.v5.ucCntlFlag &
2874                                                              ATOM_PLL_CNTL_FLAG_PLL_POST_DIV_EN) ? true : false;
2875                                 dividers->enable_dithen = (args.v5.ucCntlFlag &
2876                                                            ATOM_PLL_CNTL_FLAG_FRACTION_DISABLE) ? false : true;
2877                                 dividers->whole_fb_div = le16_to_cpu(args.v5.ulFbDiv.usFbDiv);
2878                                 dividers->frac_fb_div = le16_to_cpu(args.v5.ulFbDiv.usFbDivFrac);
2879                                 dividers->ref_div = args.v5.ucRefDiv;
2880                                 dividers->vco_mode = (args.v5.ucCntlFlag &
2881                                                       ATOM_PLL_CNTL_FLAG_MPLL_VCO_MODE) ? 1 : 0;
2882                         }
2883                 }
2884                 break;
2885         case 4:
2886                 /* fusion */
2887                 args.v4.ulClock = cpu_to_le32(clock);   /* 10 khz */
2888
2889                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2890
2891                 dividers->post_divider = dividers->post_div = args.v4.ucPostDiv;
2892                 dividers->real_clock = le32_to_cpu(args.v4.ulClock);
2893                 break;
2894         case 6:
2895                 /* CI */
2896                 /* COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK, COMPUTE_GPUCLK_INPUT_FLAG_SCLK */
2897                 args.v6_in.ulClock.ulComputeClockFlag = clock_type;
2898                 args.v6_in.ulClock.ulClockFreq = cpu_to_le32(clock);    /* 10 khz */
2899
2900                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2901
2902                 dividers->whole_fb_div = le16_to_cpu(args.v6_out.ulFbDiv.usFbDiv);
2903                 dividers->frac_fb_div = le16_to_cpu(args.v6_out.ulFbDiv.usFbDivFrac);
2904                 dividers->ref_div = args.v6_out.ucPllRefDiv;
2905                 dividers->post_div = args.v6_out.ucPllPostDiv;
2906                 dividers->flags = args.v6_out.ucPllCntlFlag;
2907                 dividers->real_clock = le32_to_cpu(args.v6_out.ulClock.ulClock);
2908                 dividers->post_divider = args.v6_out.ulClock.ucPostDiv;
2909                 break;
2910         default:
2911                 return -EINVAL;
2912         }
2913         return 0;
2914 }
2915
2916 int radeon_atom_get_memory_pll_dividers(struct radeon_device *rdev,
2917                                         u32 clock,
2918                                         bool strobe_mode,
2919                                         struct atom_mpll_param *mpll_param)
2920 {
2921         COMPUTE_MEMORY_CLOCK_PARAM_PARAMETERS_V2_1 args;
2922         int index = GetIndexIntoMasterTable(COMMAND, ComputeMemoryClockParam);
2923         u8 frev, crev;
2924
2925         memset(&args, 0, sizeof(args));
2926         memset(mpll_param, 0, sizeof(struct atom_mpll_param));
2927
2928         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2929                 return -EINVAL;
2930
2931         switch (frev) {
2932         case 2:
2933                 switch (crev) {
2934                 case 1:
2935                         /* SI */
2936                         args.ulClock = cpu_to_le32(clock);      /* 10 khz */
2937                         args.ucInputFlag = 0;
2938                         if (strobe_mode)
2939                                 args.ucInputFlag |= MPLL_INPUT_FLAG_STROBE_MODE_EN;
2940
2941                         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2942
2943                         mpll_param->clkfrac = le16_to_cpu(args.ulFbDiv.usFbDivFrac);
2944                         mpll_param->clkf = le16_to_cpu(args.ulFbDiv.usFbDiv);
2945                         mpll_param->post_div = args.ucPostDiv;
2946                         mpll_param->dll_speed = args.ucDllSpeed;
2947                         mpll_param->bwcntl = args.ucBWCntl;
2948                         mpll_param->vco_mode =
2949                                 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_VCO_MODE_MASK);
2950                         mpll_param->yclk_sel =
2951                                 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_BYPASS_DQ_PLL) ? 1 : 0;
2952                         mpll_param->qdr =
2953                                 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_QDR_ENABLE) ? 1 : 0;
2954                         mpll_param->half_rate =
2955                                 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_AD_HALF_RATE) ? 1 : 0;
2956                         break;
2957                 default:
2958                         return -EINVAL;
2959                 }
2960                 break;
2961         default:
2962                 return -EINVAL;
2963         }
2964         return 0;
2965 }
2966
2967 void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable)
2968 {
2969         DYNAMIC_CLOCK_GATING_PS_ALLOCATION args;
2970         int index = GetIndexIntoMasterTable(COMMAND, DynamicClockGating);
2971
2972         args.ucEnable = enable;
2973
2974         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2975 }
2976
2977 uint32_t radeon_atom_get_engine_clock(struct radeon_device *rdev)
2978 {
2979         GET_ENGINE_CLOCK_PS_ALLOCATION args;
2980         int index = GetIndexIntoMasterTable(COMMAND, GetEngineClock);
2981
2982         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2983         return le32_to_cpu(args.ulReturnEngineClock);
2984 }
2985
2986 uint32_t radeon_atom_get_memory_clock(struct radeon_device *rdev)
2987 {
2988         GET_MEMORY_CLOCK_PS_ALLOCATION args;
2989         int index = GetIndexIntoMasterTable(COMMAND, GetMemoryClock);
2990
2991         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2992         return le32_to_cpu(args.ulReturnMemoryClock);
2993 }
2994
2995 void radeon_atom_set_engine_clock(struct radeon_device *rdev,
2996                                   uint32_t eng_clock)
2997 {
2998         SET_ENGINE_CLOCK_PS_ALLOCATION args;
2999         int index = GetIndexIntoMasterTable(COMMAND, SetEngineClock);
3000
3001         args.ulTargetEngineClock = cpu_to_le32(eng_clock);      /* 10 khz */
3002
3003         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3004 }
3005
3006 void radeon_atom_set_memory_clock(struct radeon_device *rdev,
3007                                   uint32_t mem_clock)
3008 {
3009         SET_MEMORY_CLOCK_PS_ALLOCATION args;
3010         int index = GetIndexIntoMasterTable(COMMAND, SetMemoryClock);
3011
3012         if (rdev->flags & RADEON_IS_IGP)
3013                 return;
3014
3015         args.ulTargetMemoryClock = cpu_to_le32(mem_clock);      /* 10 khz */
3016
3017         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3018 }
3019
3020 void radeon_atom_set_engine_dram_timings(struct radeon_device *rdev,
3021                                          u32 eng_clock, u32 mem_clock)
3022 {
3023         SET_ENGINE_CLOCK_PS_ALLOCATION args;
3024         int index = GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings);
3025         u32 tmp;
3026
3027         memset(&args, 0, sizeof(args));
3028
3029         tmp = eng_clock & SET_CLOCK_FREQ_MASK;
3030         tmp |= (COMPUTE_ENGINE_PLL_PARAM << 24);
3031
3032         args.ulTargetEngineClock = cpu_to_le32(tmp);
3033         if (mem_clock)
3034                 args.sReserved.ulClock = cpu_to_le32(mem_clock & SET_CLOCK_FREQ_MASK);
3035
3036         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3037 }
3038
3039 void radeon_atom_update_memory_dll(struct radeon_device *rdev,
3040                                    u32 mem_clock)
3041 {
3042         u32 args;
3043         int index = GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings);
3044
3045         args = cpu_to_le32(mem_clock);  /* 10 khz */
3046
3047         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3048 }
3049
3050 void radeon_atom_set_ac_timing(struct radeon_device *rdev,
3051                                u32 mem_clock)
3052 {
3053         SET_MEMORY_CLOCK_PS_ALLOCATION args;
3054         int index = GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings);
3055         u32 tmp = mem_clock | (COMPUTE_MEMORY_PLL_PARAM << 24);
3056
3057         args.ulTargetMemoryClock = cpu_to_le32(tmp);    /* 10 khz */
3058
3059         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3060 }
3061
3062 union set_voltage {
3063         struct _SET_VOLTAGE_PS_ALLOCATION alloc;
3064         struct _SET_VOLTAGE_PARAMETERS v1;
3065         struct _SET_VOLTAGE_PARAMETERS_V2 v2;
3066         struct _SET_VOLTAGE_PARAMETERS_V1_3 v3;
3067 };
3068
3069 void radeon_atom_set_voltage(struct radeon_device *rdev, u16 voltage_level, u8 voltage_type)
3070 {
3071         union set_voltage args;
3072         int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3073         u8 frev, crev, volt_index = voltage_level;
3074
3075         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3076                 return;
3077
3078         /* 0xff01 is a flag rather then an actual voltage */
3079         if (voltage_level == 0xff01)
3080                 return;
3081
3082         switch (crev) {
3083         case 1:
3084                 args.v1.ucVoltageType = voltage_type;
3085                 args.v1.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_ALL_SOURCE;
3086                 args.v1.ucVoltageIndex = volt_index;
3087                 break;
3088         case 2:
3089                 args.v2.ucVoltageType = voltage_type;
3090                 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_SET_VOLTAGE;
3091                 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
3092                 break;
3093         case 3:
3094                 args.v3.ucVoltageType = voltage_type;
3095                 args.v3.ucVoltageMode = ATOM_SET_VOLTAGE;
3096                 args.v3.usVoltageLevel = cpu_to_le16(voltage_level);
3097                 break;
3098         default:
3099                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3100                 return;
3101         }
3102
3103         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3104 }
3105
3106 int radeon_atom_get_max_vddc(struct radeon_device *rdev, u8 voltage_type,
3107                              u16 voltage_id, u16 *voltage)
3108 {
3109         union set_voltage args;
3110         int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3111         u8 frev, crev;
3112
3113         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3114                 return -EINVAL;
3115
3116         switch (crev) {
3117         case 1:
3118                 return -EINVAL;
3119         case 2:
3120                 args.v2.ucVoltageType = SET_VOLTAGE_GET_MAX_VOLTAGE;
3121                 args.v2.ucVoltageMode = 0;
3122                 args.v2.usVoltageLevel = 0;
3123
3124                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3125
3126                 *voltage = le16_to_cpu(args.v2.usVoltageLevel);
3127                 break;
3128         case 3:
3129                 args.v3.ucVoltageType = voltage_type;
3130                 args.v3.ucVoltageMode = ATOM_GET_VOLTAGE_LEVEL;
3131                 args.v3.usVoltageLevel = cpu_to_le16(voltage_id);
3132
3133                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3134
3135                 *voltage = le16_to_cpu(args.v3.usVoltageLevel);
3136                 break;
3137         default:
3138                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3139                 return -EINVAL;
3140         }
3141
3142         return 0;
3143 }
3144
3145 int radeon_atom_get_leakage_vddc_based_on_leakage_idx(struct radeon_device *rdev,
3146                                                       u16 *voltage,
3147                                                       u16 leakage_idx)
3148 {
3149         return radeon_atom_get_max_vddc(rdev, VOLTAGE_TYPE_VDDC, leakage_idx, voltage);
3150 }
3151
3152 int radeon_atom_get_leakage_id_from_vbios(struct radeon_device *rdev,
3153                                           u16 *leakage_id)
3154 {
3155         union set_voltage args;
3156         int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3157         u8 frev, crev;
3158
3159         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3160                 return -EINVAL;
3161
3162         switch (crev) {
3163         case 3:
3164         case 4:
3165                 args.v3.ucVoltageType = 0;
3166                 args.v3.ucVoltageMode = ATOM_GET_LEAKAGE_ID;
3167                 args.v3.usVoltageLevel = 0;
3168
3169                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3170
3171                 *leakage_id = le16_to_cpu(args.v3.usVoltageLevel);
3172                 break;
3173         default:
3174                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3175                 return -EINVAL;
3176         }
3177
3178         return 0;
3179 }
3180
3181 int radeon_atom_get_leakage_vddc_based_on_leakage_params(struct radeon_device *rdev,
3182                                                          u16 *vddc, u16 *vddci,
3183                                                          u16 virtual_voltage_id,
3184                                                          u16 vbios_voltage_id)
3185 {
3186         int index = GetIndexIntoMasterTable(DATA, ASIC_ProfilingInfo);
3187         u8 frev, crev;
3188         u16 data_offset, size;
3189         int i, j;
3190         ATOM_ASIC_PROFILING_INFO_V2_1 *profile;
3191         u16 *leakage_bin, *vddc_id_buf, *vddc_buf, *vddci_id_buf, *vddci_buf;
3192
3193         *vddc = 0;
3194         *vddci = 0;
3195
3196         if (!atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3197                                     &frev, &crev, &data_offset))
3198                 return -EINVAL;
3199
3200         profile = (ATOM_ASIC_PROFILING_INFO_V2_1 *)
3201                 (rdev->mode_info.atom_context->bios + data_offset);
3202
3203         switch (frev) {
3204         case 1:
3205                 return -EINVAL;
3206         case 2:
3207                 switch (crev) {
3208                 case 1:
3209                         if (size < sizeof(ATOM_ASIC_PROFILING_INFO_V2_1))
3210                                 return -EINVAL;
3211                         leakage_bin = (u16 *)
3212                                 (rdev->mode_info.atom_context->bios + data_offset +
3213                                  le16_to_cpu(profile->usLeakageBinArrayOffset));
3214                         vddc_id_buf = (u16 *)
3215                                 (rdev->mode_info.atom_context->bios + data_offset +
3216                                  le16_to_cpu(profile->usElbVDDC_IdArrayOffset));
3217                         vddc_buf = (u16 *)
3218                                 (rdev->mode_info.atom_context->bios + data_offset +
3219                                  le16_to_cpu(profile->usElbVDDC_LevelArrayOffset));
3220                         vddci_id_buf = (u16 *)
3221                                 (rdev->mode_info.atom_context->bios + data_offset +
3222                                  le16_to_cpu(profile->usElbVDDCI_IdArrayOffset));
3223                         vddci_buf = (u16 *)
3224                                 (rdev->mode_info.atom_context->bios + data_offset +
3225                                  le16_to_cpu(profile->usElbVDDCI_LevelArrayOffset));
3226
3227                         if (profile->ucElbVDDC_Num > 0) {
3228                                 for (i = 0; i < profile->ucElbVDDC_Num; i++) {
3229                                         if (vddc_id_buf[i] == virtual_voltage_id) {
3230                                                 for (j = 0; j < profile->ucLeakageBinNum; j++) {
3231                                                         if (vbios_voltage_id <= leakage_bin[j]) {
3232                                                                 *vddc = vddc_buf[j * profile->ucElbVDDC_Num + i];
3233                                                                 break;
3234                                                         }
3235                                                 }
3236                                                 break;
3237                                         }
3238                                 }
3239                         }
3240                         if (profile->ucElbVDDCI_Num > 0) {
3241                                 for (i = 0; i < profile->ucElbVDDCI_Num; i++) {
3242                                         if (vddci_id_buf[i] == virtual_voltage_id) {
3243                                                 for (j = 0; j < profile->ucLeakageBinNum; j++) {
3244                                                         if (vbios_voltage_id <= leakage_bin[j]) {
3245                                                                 *vddci = vddci_buf[j * profile->ucElbVDDCI_Num + i];
3246                                                                 break;
3247                                                         }
3248                                                 }
3249                                                 break;
3250                                         }
3251                                 }
3252                         }
3253                         break;
3254                 default:
3255                         DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3256                         return -EINVAL;
3257                 }
3258                 break;
3259         default:
3260                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3261                 return -EINVAL;
3262         }
3263
3264         return 0;
3265 }
3266
3267 union get_voltage_info {
3268         struct  _GET_VOLTAGE_INFO_INPUT_PARAMETER_V1_2 in;
3269         struct  _GET_EVV_VOLTAGE_INFO_OUTPUT_PARAMETER_V1_2 evv_out;
3270 };
3271
3272 int radeon_atom_get_voltage_evv(struct radeon_device *rdev,
3273                                 u16 virtual_voltage_id,
3274                                 u16 *voltage)
3275 {
3276         int index = GetIndexIntoMasterTable(COMMAND, GetVoltageInfo);
3277         u32 entry_id;
3278         u32 count = rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk.count;
3279         union get_voltage_info args;
3280
3281         for (entry_id = 0; entry_id < count; entry_id++) {
3282                 if (rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk.entries[entry_id].v ==
3283                     virtual_voltage_id)
3284                         break;
3285         }
3286
3287         if (entry_id >= count)
3288                 return -EINVAL;
3289
3290         args.in.ucVoltageType = VOLTAGE_TYPE_VDDC;
3291         args.in.ucVoltageMode = ATOM_GET_VOLTAGE_EVV_VOLTAGE;
3292         args.in.usVoltageLevel = cpu_to_le16(virtual_voltage_id);
3293         args.in.ulSCLKFreq =
3294                 cpu_to_le32(rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk.entries[entry_id].clk);
3295
3296         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3297
3298         *voltage = le16_to_cpu(args.evv_out.usVoltageLevel);
3299
3300         return 0;
3301 }
3302
3303 int radeon_atom_get_voltage_gpio_settings(struct radeon_device *rdev,
3304                                           u16 voltage_level, u8 voltage_type,
3305                                           u32 *gpio_value, u32 *gpio_mask)
3306 {
3307         union set_voltage args;
3308         int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3309         u8 frev, crev;
3310
3311         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3312                 return -EINVAL;
3313
3314         switch (crev) {
3315         case 1:
3316                 return -EINVAL;
3317         case 2:
3318                 args.v2.ucVoltageType = voltage_type;
3319                 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_GET_GPIOMASK;
3320                 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
3321
3322                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3323
3324                 *gpio_mask = le32_to_cpu(*(u32 *)&args.v2);
3325
3326                 args.v2.ucVoltageType = voltage_type;
3327                 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_GET_GPIOVAL;
3328                 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
3329
3330                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3331
3332                 *gpio_value = le32_to_cpu(*(u32 *)&args.v2);
3333                 break;
3334         default:
3335                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3336                 return -EINVAL;
3337         }
3338
3339         return 0;
3340 }
3341
3342 union voltage_object_info {
3343         struct _ATOM_VOLTAGE_OBJECT_INFO v1;
3344         struct _ATOM_VOLTAGE_OBJECT_INFO_V2 v2;
3345         struct _ATOM_VOLTAGE_OBJECT_INFO_V3_1 v3;
3346 };
3347
3348 union voltage_object {
3349         struct _ATOM_VOLTAGE_OBJECT v1;
3350         struct _ATOM_VOLTAGE_OBJECT_V2 v2;
3351         union _ATOM_VOLTAGE_OBJECT_V3 v3;
3352 };
3353
3354 static ATOM_VOLTAGE_OBJECT *atom_lookup_voltage_object_v1(ATOM_VOLTAGE_OBJECT_INFO *v1,
3355                                                           u8 voltage_type)
3356 {
3357         u32 size = le16_to_cpu(v1->sHeader.usStructureSize);
3358         u32 offset = offsetof(ATOM_VOLTAGE_OBJECT_INFO, asVoltageObj[0]);
3359         u8 *start = (u8 *)v1;
3360
3361         while (offset < size) {
3362                 ATOM_VOLTAGE_OBJECT *vo = (ATOM_VOLTAGE_OBJECT *)(start + offset);
3363                 if (vo->ucVoltageType == voltage_type)
3364                         return vo;
3365                 offset += offsetof(ATOM_VOLTAGE_OBJECT, asFormula.ucVIDAdjustEntries) +
3366                         vo->asFormula.ucNumOfVoltageEntries;
3367         }
3368         return NULL;
3369 }
3370
3371 static ATOM_VOLTAGE_OBJECT_V2 *atom_lookup_voltage_object_v2(ATOM_VOLTAGE_OBJECT_INFO_V2 *v2,
3372                                                              u8 voltage_type)
3373 {
3374         u32 size = le16_to_cpu(v2->sHeader.usStructureSize);
3375         u32 offset = offsetof(ATOM_VOLTAGE_OBJECT_INFO_V2, asVoltageObj[0]);
3376         u8 *start = (u8*)v2;
3377
3378         while (offset < size) {
3379                 ATOM_VOLTAGE_OBJECT_V2 *vo = (ATOM_VOLTAGE_OBJECT_V2 *)(start + offset);
3380                 if (vo->ucVoltageType == voltage_type)
3381                         return vo;
3382                 offset += offsetof(ATOM_VOLTAGE_OBJECT_V2, asFormula.asVIDAdjustEntries) +
3383                         (vo->asFormula.ucNumOfVoltageEntries * sizeof(VOLTAGE_LUT_ENTRY));
3384         }
3385         return NULL;
3386 }
3387
3388 static ATOM_VOLTAGE_OBJECT_V3 *atom_lookup_voltage_object_v3(ATOM_VOLTAGE_OBJECT_INFO_V3_1 *v3,
3389                                                              u8 voltage_type, u8 voltage_mode)
3390 {
3391         u32 size = le16_to_cpu(v3->sHeader.usStructureSize);
3392         u32 offset = offsetof(ATOM_VOLTAGE_OBJECT_INFO_V3_1, asVoltageObj[0]);
3393         u8 *start = (u8*)v3;
3394
3395         while (offset < size) {
3396                 ATOM_VOLTAGE_OBJECT_V3 *vo = (ATOM_VOLTAGE_OBJECT_V3 *)(start + offset);
3397                 if ((vo->asGpioVoltageObj.sHeader.ucVoltageType == voltage_type) &&
3398                     (vo->asGpioVoltageObj.sHeader.ucVoltageMode == voltage_mode))
3399                         return vo;
3400                 offset += le16_to_cpu(vo->asGpioVoltageObj.sHeader.usSize);
3401         }
3402         return NULL;
3403 }
3404
3405 bool
3406 radeon_atom_is_voltage_gpio(struct radeon_device *rdev,
3407                             u8 voltage_type, u8 voltage_mode)
3408 {
3409         int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3410         u8 frev, crev;
3411         u16 data_offset, size;
3412         union voltage_object_info *voltage_info;
3413         union voltage_object *voltage_object = NULL;
3414
3415         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3416                                    &frev, &crev, &data_offset)) {
3417                 voltage_info = (union voltage_object_info *)
3418                         (rdev->mode_info.atom_context->bios + data_offset);
3419
3420                 switch (frev) {
3421                 case 1:
3422                 case 2:
3423                         switch (crev) {
3424                         case 1:
3425                                 voltage_object = (union voltage_object *)
3426                                         atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3427                                 if (voltage_object &&
3428                                     (voltage_object->v1.asControl.ucVoltageControlId == VOLTAGE_CONTROLLED_BY_GPIO))
3429                                         return true;
3430                                 break;
3431                         case 2:
3432                                 voltage_object = (union voltage_object *)
3433                                         atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3434                                 if (voltage_object &&
3435                                     (voltage_object->v2.asControl.ucVoltageControlId == VOLTAGE_CONTROLLED_BY_GPIO))
3436                                         return true;
3437                                 break;
3438                         default:
3439                                 DRM_ERROR("unknown voltage object table\n");
3440                                 return false;
3441                         }
3442                         break;
3443                 case 3:
3444                         switch (crev) {
3445                         case 1:
3446                                 if (atom_lookup_voltage_object_v3(&voltage_info->v3,
3447                                                                   voltage_type, voltage_mode))
3448                                         return true;
3449                                 break;
3450                         default:
3451                                 DRM_ERROR("unknown voltage object table\n");
3452                                 return false;
3453                         }
3454                         break;
3455                 default:
3456                         DRM_ERROR("unknown voltage object table\n");
3457                         return false;
3458                 }
3459
3460         }
3461         return false;
3462 }
3463
3464 int radeon_atom_get_svi2_info(struct radeon_device *rdev,
3465                               u8 voltage_type,
3466                               u8 *svd_gpio_id, u8 *svc_gpio_id)
3467 {
3468         int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3469         u8 frev, crev;
3470         u16 data_offset, size;
3471         union voltage_object_info *voltage_info;
3472         union voltage_object *voltage_object = NULL;
3473
3474         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3475                                    &frev, &crev, &data_offset)) {
3476                 voltage_info = (union voltage_object_info *)
3477                         (rdev->mode_info.atom_context->bios + data_offset);
3478
3479                 switch (frev) {
3480                 case 3:
3481                         switch (crev) {
3482                         case 1:
3483                                 voltage_object = (union voltage_object *)
3484                                         atom_lookup_voltage_object_v3(&voltage_info->v3,
3485                                                                       voltage_type,
3486                                                                       VOLTAGE_OBJ_SVID2);
3487                                 if (voltage_object) {
3488                                         *svd_gpio_id = voltage_object->v3.asSVID2Obj.ucSVDGpioId;
3489                                         *svc_gpio_id = voltage_object->v3.asSVID2Obj.ucSVCGpioId;
3490                                 } else {
3491                                         return -EINVAL;
3492                                 }
3493                                 break;
3494                         default:
3495                                 DRM_ERROR("unknown voltage object table\n");
3496                                 return -EINVAL;
3497                         }
3498                         break;
3499                 default:
3500                         DRM_ERROR("unknown voltage object table\n");
3501                         return -EINVAL;
3502                 }
3503
3504         }
3505         return 0;
3506 }
3507
3508 int radeon_atom_get_max_voltage(struct radeon_device *rdev,
3509                                 u8 voltage_type, u16 *max_voltage)
3510 {
3511         int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3512         u8 frev, crev;
3513         u16 data_offset, size;
3514         union voltage_object_info *voltage_info;
3515         union voltage_object *voltage_object = NULL;
3516
3517         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3518                                    &frev, &crev, &data_offset)) {
3519                 voltage_info = (union voltage_object_info *)
3520                         (rdev->mode_info.atom_context->bios + data_offset);
3521
3522                 switch (crev) {
3523                 case 1:
3524                         voltage_object = (union voltage_object *)
3525                                 atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3526                         if (voltage_object) {
3527                                 ATOM_VOLTAGE_FORMULA *formula =
3528                                         &voltage_object->v1.asFormula;
3529                                 if (formula->ucFlag & 1)
3530                                         *max_voltage =
3531                                                 le16_to_cpu(formula->usVoltageBaseLevel) +
3532                                                 formula->ucNumOfVoltageEntries / 2 *
3533                                                 le16_to_cpu(formula->usVoltageStep);
3534                                 else
3535                                         *max_voltage =
3536                                                 le16_to_cpu(formula->usVoltageBaseLevel) +
3537                                                 (formula->ucNumOfVoltageEntries - 1) *
3538                                                 le16_to_cpu(formula->usVoltageStep);
3539                                 return 0;
3540                         }
3541                         break;
3542                 case 2:
3543                         voltage_object = (union voltage_object *)
3544                                 atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3545                         if (voltage_object) {
3546                                 ATOM_VOLTAGE_FORMULA_V2 *formula =
3547                                         &voltage_object->v2.asFormula;
3548                                 if (formula->ucNumOfVoltageEntries) {
3549                                         VOLTAGE_LUT_ENTRY *lut = (VOLTAGE_LUT_ENTRY *)
3550                                                 ((u8 *)&formula->asVIDAdjustEntries[0] +
3551                                                  (sizeof(VOLTAGE_LUT_ENTRY) * (formula->ucNumOfVoltageEntries - 1)));
3552                                         *max_voltage =
3553                                                 le16_to_cpu(lut->usVoltageValue);
3554                                         return 0;
3555                                 }
3556                         }
3557                         break;
3558                 default:
3559                         DRM_ERROR("unknown voltage object table\n");
3560                         return -EINVAL;
3561                 }
3562
3563         }
3564         return -EINVAL;
3565 }
3566
3567 int radeon_atom_get_min_voltage(struct radeon_device *rdev,
3568                                 u8 voltage_type, u16 *min_voltage)
3569 {
3570         int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3571         u8 frev, crev;
3572         u16 data_offset, size;
3573         union voltage_object_info *voltage_info;
3574         union voltage_object *voltage_object = NULL;
3575
3576         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3577                                    &frev, &crev, &data_offset)) {
3578                 voltage_info = (union voltage_object_info *)
3579                         (rdev->mode_info.atom_context->bios + data_offset);
3580
3581                 switch (crev) {
3582                 case 1:
3583                         voltage_object = (union voltage_object *)
3584                                 atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3585                         if (voltage_object) {
3586                                 ATOM_VOLTAGE_FORMULA *formula =
3587                                         &voltage_object->v1.asFormula;
3588                                 *min_voltage =
3589                                         le16_to_cpu(formula->usVoltageBaseLevel);
3590                                 return 0;
3591                         }
3592                         break;
3593                 case 2:
3594                         voltage_object = (union voltage_object *)
3595                                 atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3596                         if (voltage_object) {
3597                                 ATOM_VOLTAGE_FORMULA_V2 *formula =
3598                                         &voltage_object->v2.asFormula;
3599                                 if (formula->ucNumOfVoltageEntries) {
3600                                         *min_voltage =
3601                                                 le16_to_cpu(formula->asVIDAdjustEntries[
3602                                                                     0
3603                                                                     ].usVoltageValue);
3604                                         return 0;
3605                                 }
3606                         }
3607                         break;
3608                 default:
3609                         DRM_ERROR("unknown voltage object table\n");
3610                         return -EINVAL;
3611                 }
3612
3613         }
3614         return -EINVAL;
3615 }
3616
3617 int radeon_atom_get_voltage_step(struct radeon_device *rdev,
3618                                  u8 voltage_type, u16 *voltage_step)
3619 {
3620         int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3621         u8 frev, crev;
3622         u16 data_offset, size;
3623         union voltage_object_info *voltage_info;
3624         union voltage_object *voltage_object = NULL;
3625
3626         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3627                                    &frev, &crev, &data_offset)) {
3628                 voltage_info = (union voltage_object_info *)
3629                         (rdev->mode_info.atom_context->bios + data_offset);
3630
3631                 switch (crev) {
3632                 case 1:
3633                         voltage_object = (union voltage_object *)
3634                                 atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3635                         if (voltage_object) {
3636                                 ATOM_VOLTAGE_FORMULA *formula =
3637                                         &voltage_object->v1.asFormula;
3638                                 if (formula->ucFlag & 1)
3639                                         *voltage_step =
3640                                                 (le16_to_cpu(formula->usVoltageStep) + 1) / 2;
3641                                 else
3642                                         *voltage_step =
3643                                                 le16_to_cpu(formula->usVoltageStep);
3644                                 return 0;
3645                         }
3646                         break;
3647                 case 2:
3648                         return -EINVAL;
3649                 default:
3650                         DRM_ERROR("unknown voltage object table\n");
3651                         return -EINVAL;
3652                 }
3653
3654         }
3655         return -EINVAL;
3656 }
3657
3658 int radeon_atom_round_to_true_voltage(struct radeon_device *rdev,
3659                                       u8 voltage_type,
3660                                       u16 nominal_voltage,
3661                                       u16 *true_voltage)
3662 {
3663         u16 min_voltage, max_voltage, voltage_step;
3664
3665         if (radeon_atom_get_max_voltage(rdev, voltage_type, &max_voltage))
3666                 return -EINVAL;
3667         if (radeon_atom_get_min_voltage(rdev, voltage_type, &min_voltage))
3668                 return -EINVAL;
3669         if (radeon_atom_get_voltage_step(rdev, voltage_type, &voltage_step))
3670                 return -EINVAL;
3671
3672         if (nominal_voltage <= min_voltage)
3673                 *true_voltage = min_voltage;
3674         else if (nominal_voltage >= max_voltage)
3675                 *true_voltage = max_voltage;
3676         else
3677                 *true_voltage = min_voltage +
3678                         ((nominal_voltage - min_voltage) / voltage_step) *
3679                         voltage_step;
3680
3681         return 0;
3682 }
3683
3684 int radeon_atom_get_voltage_table(struct radeon_device *rdev,
3685                                   u8 voltage_type, u8 voltage_mode,
3686                                   struct atom_voltage_table *voltage_table)
3687 {
3688         int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3689         u8 frev, crev;
3690         u16 data_offset, size;
3691         int i, ret;
3692         union voltage_object_info *voltage_info;
3693         union voltage_object *voltage_object = NULL;
3694
3695         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3696                                    &frev, &crev, &data_offset)) {
3697                 voltage_info = (union voltage_object_info *)
3698                         (rdev->mode_info.atom_context->bios + data_offset);
3699
3700                 switch (frev) {
3701                 case 1:
3702                 case 2:
3703                         switch (crev) {
3704                         case 1:
3705                                 DRM_ERROR("old table version %d, %d\n", frev, crev);
3706                                 return -EINVAL;
3707                         case 2:
3708                                 voltage_object = (union voltage_object *)
3709                                         atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3710                                 if (voltage_object) {
3711                                         ATOM_VOLTAGE_FORMULA_V2 *formula =
3712                                                 &voltage_object->v2.asFormula;
3713                                         VOLTAGE_LUT_ENTRY *lut;
3714                                         if (formula->ucNumOfVoltageEntries > MAX_VOLTAGE_ENTRIES)
3715                                                 return -EINVAL;
3716                                         lut = &formula->asVIDAdjustEntries[0];
3717                                         for (i = 0; i < formula->ucNumOfVoltageEntries; i++) {
3718                                                 voltage_table->entries[i].value =
3719                                                         le16_to_cpu(lut->usVoltageValue);
3720                                                 ret = radeon_atom_get_voltage_gpio_settings(rdev,
3721                                                                                             voltage_table->entries[i].value,
3722                                                                                             voltage_type,
3723                                                                                             &voltage_table->entries[i].smio_low,
3724                                                                                             &voltage_table->mask_low);
3725                                                 if (ret)
3726                                                         return ret;
3727                                                 lut = (VOLTAGE_LUT_ENTRY *)
3728                                                         ((u8 *)lut + sizeof(VOLTAGE_LUT_ENTRY));
3729                                         }
3730                                         voltage_table->count = formula->ucNumOfVoltageEntries;
3731                                         return 0;
3732                                 }
3733                                 break;
3734                         default:
3735                                 DRM_ERROR("unknown voltage object table\n");
3736                                 return -EINVAL;
3737                         }
3738                         break;
3739                 case 3:
3740                         switch (crev) {
3741                         case 1:
3742                                 voltage_object = (union voltage_object *)
3743                                         atom_lookup_voltage_object_v3(&voltage_info->v3,
3744                                                                       voltage_type, voltage_mode);
3745                                 if (voltage_object) {
3746                                         ATOM_GPIO_VOLTAGE_OBJECT_V3 *gpio =
3747                                                 &voltage_object->v3.asGpioVoltageObj;
3748                                         VOLTAGE_LUT_ENTRY_V2 *lut;
3749                                         if (gpio->ucGpioEntryNum > MAX_VOLTAGE_ENTRIES)
3750                                                 return -EINVAL;
3751                                         lut = &gpio->asVolGpioLut[0];
3752                                         for (i = 0; i < gpio->ucGpioEntryNum; i++) {
3753                                                 voltage_table->entries[i].value =
3754                                                         le16_to_cpu(lut->usVoltageValue);
3755                                                 voltage_table->entries[i].smio_low =
3756                                                         le32_to_cpu(lut->ulVoltageId);
3757                                                 lut = (VOLTAGE_LUT_ENTRY_V2 *)
3758                                                         ((u8 *)lut + sizeof(VOLTAGE_LUT_ENTRY_V2));
3759                                         }
3760                                         voltage_table->mask_low = le32_to_cpu(gpio->ulGpioMaskVal);
3761                                         voltage_table->count = gpio->ucGpioEntryNum;
3762                                         voltage_table->phase_delay = gpio->ucPhaseDelay;
3763                                         return 0;
3764                                 }
3765                                 break;
3766                         default:
3767                                 DRM_ERROR("unknown voltage object table\n");
3768                                 return -EINVAL;
3769                         }
3770                         break;
3771                 default:
3772                         DRM_ERROR("unknown voltage object table\n");
3773                         return -EINVAL;
3774                 }
3775         }
3776         return -EINVAL;
3777 }
3778
3779 union vram_info {
3780         struct _ATOM_VRAM_INFO_V3 v1_3;
3781         struct _ATOM_VRAM_INFO_V4 v1_4;
3782         struct _ATOM_VRAM_INFO_HEADER_V2_1 v2_1;
3783 };
3784
3785 int radeon_atom_get_memory_info(struct radeon_device *rdev,
3786                                 u8 module_index, struct atom_memory_info *mem_info)
3787 {
3788         int index = GetIndexIntoMasterTable(DATA, VRAM_Info);
3789         u8 frev, crev, i;
3790         u16 data_offset, size;
3791         union vram_info *vram_info;
3792
3793         memset(mem_info, 0, sizeof(struct atom_memory_info));
3794
3795         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3796                                    &frev, &crev, &data_offset)) {
3797                 vram_info = (union vram_info *)
3798                         (rdev->mode_info.atom_context->bios + data_offset);
3799                 switch (frev) {
3800                 case 1:
3801                         switch (crev) {
3802                         case 3:
3803                                 /* r6xx */
3804                                 if (module_index < vram_info->v1_3.ucNumOfVRAMModule) {
3805                                         ATOM_VRAM_MODULE_V3 *vram_module =
3806                                                 (ATOM_VRAM_MODULE_V3 *)vram_info->v1_3.aVramInfo;
3807
3808                                         for (i = 0; i < module_index; i++) {
3809                                                 if (le16_to_cpu(vram_module->usSize) == 0)
3810                                                         return -EINVAL;
3811                                                 vram_module = (ATOM_VRAM_MODULE_V3 *)
3812                                                         ((u8 *)vram_module + le16_to_cpu(vram_module->usSize));
3813                                         }
3814                                         mem_info->mem_vendor = vram_module->asMemory.ucMemoryVenderID & 0xf;
3815                                         mem_info->mem_type = vram_module->asMemory.ucMemoryType & 0xf0;
3816                                 } else
3817                                         return -EINVAL;
3818                                 break;
3819                         case 4:
3820                                 /* r7xx, evergreen */
3821                                 if (module_index < vram_info->v1_4.ucNumOfVRAMModule) {
3822                                         ATOM_VRAM_MODULE_V4 *vram_module =
3823                                                 (ATOM_VRAM_MODULE_V4 *)vram_info->v1_4.aVramInfo;
3824
3825                                         for (i = 0; i < module_index; i++) {
3826                                                 if (le16_to_cpu(vram_module->usModuleSize) == 0)
3827                                                         return -EINVAL;
3828                                                 vram_module = (ATOM_VRAM_MODULE_V4 *)
3829                                                         ((u8 *)vram_module + le16_to_cpu(vram_module->usModuleSize));
3830                                         }
3831                                         mem_info->mem_vendor = vram_module->ucMemoryVenderID & 0xf;
3832                                         mem_info->mem_type = vram_module->ucMemoryType & 0xf0;
3833                                 } else
3834                                         return -EINVAL;
3835                                 break;
3836                         default:
3837                                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3838                                 return -EINVAL;
3839                         }
3840                         break;
3841                 case 2:
3842                         switch (crev) {
3843                         case 1:
3844                                 /* ni */
3845                                 if (module_index < vram_info->v2_1.ucNumOfVRAMModule) {
3846                                         ATOM_VRAM_MODULE_V7 *vram_module =
3847                                                 (ATOM_VRAM_MODULE_V7 *)vram_info->v2_1.aVramInfo;
3848
3849                                         for (i = 0; i < module_index; i++) {
3850                                                 if (le16_to_cpu(vram_module->usModuleSize) == 0)
3851                                                         return -EINVAL;
3852                                                 vram_module = (ATOM_VRAM_MODULE_V7 *)
3853                                                         ((u8 *)vram_module + le16_to_cpu(vram_module->usModuleSize));
3854                                         }
3855                                         mem_info->mem_vendor = vram_module->ucMemoryVenderID & 0xf;
3856                                         mem_info->mem_type = vram_module->ucMemoryType & 0xf0;
3857                                 } else
3858                                         return -EINVAL;
3859                                 break;
3860                         default:
3861                                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3862                                 return -EINVAL;
3863                         }
3864                         break;
3865                 default:
3866                         DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3867                         return -EINVAL;
3868                 }
3869                 return 0;
3870         }
3871         return -EINVAL;
3872 }
3873
3874 int radeon_atom_get_mclk_range_table(struct radeon_device *rdev,
3875                                      bool gddr5, u8 module_index,
3876                                      struct atom_memory_clock_range_table *mclk_range_table)
3877 {
3878         int index = GetIndexIntoMasterTable(DATA, VRAM_Info);
3879         u8 frev, crev, i;
3880         u16 data_offset, size;
3881         union vram_info *vram_info;
3882         u32 mem_timing_size = gddr5 ?
3883                 sizeof(ATOM_MEMORY_TIMING_FORMAT_V2) : sizeof(ATOM_MEMORY_TIMING_FORMAT);
3884
3885         memset(mclk_range_table, 0, sizeof(struct atom_memory_clock_range_table));
3886
3887         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3888                                    &frev, &crev, &data_offset)) {
3889                 vram_info = (union vram_info *)
3890                         (rdev->mode_info.atom_context->bios + data_offset);
3891                 switch (frev) {
3892                 case 1:
3893                         switch (crev) {
3894                         case 3:
3895                                 DRM_ERROR("old table version %d, %d\n", frev, crev);
3896                                 return -EINVAL;
3897                         case 4:
3898                                 /* r7xx, evergreen */
3899                                 if (module_index < vram_info->v1_4.ucNumOfVRAMModule) {
3900                                         ATOM_VRAM_MODULE_V4 *vram_module =
3901                                                 (ATOM_VRAM_MODULE_V4 *)vram_info->v1_4.aVramInfo;
3902                                         ATOM_MEMORY_TIMING_FORMAT *format;
3903
3904                                         for (i = 0; i < module_index; i++) {
3905                                                 if (le16_to_cpu(vram_module->usModuleSize) == 0)
3906                                                         return -EINVAL;
3907                                                 vram_module = (ATOM_VRAM_MODULE_V4 *)
3908                                                         ((u8 *)vram_module + le16_to_cpu(vram_module->usModuleSize));
3909                                         }
3910                                         mclk_range_table->num_entries = (u8)
3911                                                 ((le16_to_cpu(vram_module->usModuleSize) - offsetof(ATOM_VRAM_MODULE_V4, asMemTiming)) /
3912                                                  mem_timing_size);
3913                                         format = &vram_module->asMemTiming[0];
3914                                         for (i = 0; i < mclk_range_table->num_entries; i++) {
3915                                                 mclk_range_table->mclk[i] = le32_to_cpu(format->ulClkRange);
3916                                                 format = (ATOM_MEMORY_TIMING_FORMAT *)
3917                                                         ((u8 *)format + mem_timing_size);
3918                                         }
3919                                 } else
3920                                         return -EINVAL;
3921                                 break;
3922                         default:
3923                                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3924                                 return -EINVAL;
3925                         }
3926                         break;
3927                 case 2:
3928                         DRM_ERROR("new table version %d, %d\n", frev, crev);
3929                         return -EINVAL;
3930                 default:
3931                         DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3932                         return -EINVAL;
3933                 }
3934                 return 0;
3935         }
3936         return -EINVAL;
3937 }
3938
3939 #define MEM_ID_MASK           0xff000000
3940 #define MEM_ID_SHIFT          24
3941 #define CLOCK_RANGE_MASK      0x00ffffff
3942 #define CLOCK_RANGE_SHIFT     0
3943 #define LOW_NIBBLE_MASK       0xf
3944 #define DATA_EQU_PREV         0
3945 #define DATA_FROM_TABLE       4
3946
3947 int radeon_atom_init_mc_reg_table(struct radeon_device *rdev,
3948                                   u8 module_index,
3949                                   struct atom_mc_reg_table *reg_table)
3950 {
3951         int index = GetIndexIntoMasterTable(DATA, VRAM_Info);
3952         u8 frev, crev, num_entries, t_mem_id, num_ranges = 0;
3953         u32 i = 0, j;
3954         u16 data_offset, size;
3955         union vram_info *vram_info;
3956
3957         memset(reg_table, 0, sizeof(struct atom_mc_reg_table));
3958
3959         if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3960                                    &frev, &crev, &data_offset)) {
3961                 vram_info = (union vram_info *)
3962                         (rdev->mode_info.atom_context->bios + data_offset);
3963                 switch (frev) {
3964                 case 1:
3965                         DRM_ERROR("old table version %d, %d\n", frev, crev);
3966                         return -EINVAL;
3967                 case 2:
3968                         switch (crev) {
3969                         case 1:
3970                                 if (module_index < vram_info->v2_1.ucNumOfVRAMModule) {
3971                                         ATOM_INIT_REG_BLOCK *reg_block =
3972                                                 (ATOM_INIT_REG_BLOCK *)
3973                                                 ((u8 *)vram_info + le16_to_cpu(vram_info->v2_1.usMemClkPatchTblOffset));
3974                                         ATOM_MEMORY_SETTING_DATA_BLOCK *reg_data =
3975                                                 (ATOM_MEMORY_SETTING_DATA_BLOCK *)
3976                                                 ((u8 *)reg_block + (2 * sizeof(u16)) +
3977                                                  le16_to_cpu(reg_block->usRegIndexTblSize));
3978                                         ATOM_INIT_REG_INDEX_FORMAT *format = &reg_block->asRegIndexBuf[0];
3979                                         num_entries = (u8)((le16_to_cpu(reg_block->usRegIndexTblSize)) /
3980                                                            sizeof(ATOM_INIT_REG_INDEX_FORMAT)) - 1;
3981                                         if (num_entries > VBIOS_MC_REGISTER_ARRAY_SIZE)
3982                                                 return -EINVAL;
3983                                         while (i < num_entries) {
3984                                                 if (format->ucPreRegDataLength & ACCESS_PLACEHOLDER)
3985                                                         break;
3986                                                 reg_table->mc_reg_address[i].s1 =
3987                                                         (u16)(le16_to_cpu(format->usRegIndex));
3988                                                 reg_table->mc_reg_address[i].pre_reg_data =
3989                                                         (u8)(format->ucPreRegDataLength);
3990                                                 i++;
3991                                                 format = (ATOM_INIT_REG_INDEX_FORMAT *)
3992                                                         ((u8 *)format + sizeof(ATOM_INIT_REG_INDEX_FORMAT));
3993                                         }
3994                                         reg_table->last = i;
3995                                         while ((le32_to_cpu(*(u32 *)reg_data) != END_OF_REG_DATA_BLOCK) &&
3996                                                (num_ranges < VBIOS_MAX_AC_TIMING_ENTRIES)) {
3997                                                 t_mem_id = (u8)((le32_to_cpu(*(u32 *)reg_data) & MEM_ID_MASK)
3998                                                                 >> MEM_ID_SHIFT);
3999                                                 if (module_index == t_mem_id) {
4000                                                         reg_table->mc_reg_table_entry[num_ranges].mclk_max =
4001                                                                 (u32)((le32_to_cpu(*(u32 *)reg_data) & CLOCK_RANGE_MASK)
4002                                                                       >> CLOCK_RANGE_SHIFT);
4003                                                         for (i = 0, j = 1; i < reg_table->last; i++) {
4004                                                                 if ((reg_table->mc_reg_address[i].pre_reg_data & LOW_NIBBLE_MASK) == DATA_FROM_TABLE) {
4005                                                                         reg_table->mc_reg_table_entry[num_ranges].mc_data[i] =
4006                                                                                 (u32)le32_to_cpu(*((u32 *)reg_data + j));
4007                                                                         j++;
4008                                                                 } else if ((reg_table->mc_reg_address[i].pre_reg_data & LOW_NIBBLE_MASK) == DATA_EQU_PREV) {
4009                                                                         reg_table->mc_reg_table_entry[num_ranges].mc_data[i] =
4010                                                                                 reg_table->mc_reg_table_entry[num_ranges].mc_data[i - 1];
4011                                                                 }
4012                                                         }
4013                                                         num_ranges++;
4014                                                 }
4015                                                 reg_data = (ATOM_MEMORY_SETTING_DATA_BLOCK *)
4016                                                         ((u8 *)reg_data + le16_to_cpu(reg_block->usRegDataBlkSize));
4017                                         }
4018                                         if (le32_to_cpu(*(u32 *)reg_data) != END_OF_REG_DATA_BLOCK)
4019                                                 return -EINVAL;
4020                                         reg_table->num_entries = num_ranges;
4021                                 } else
4022                                         return -EINVAL;
4023                                 break;
4024                         default:
4025                                 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
4026                                 return -EINVAL;
4027                         }
4028                         break;
4029                 default:
4030                         DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
4031                         return -EINVAL;
4032                 }
4033                 return 0;
4034         }
4035         return -EINVAL;
4036 }
4037
4038 void radeon_atom_initialize_bios_scratch_regs(struct drm_device *dev)
4039 {
4040         struct radeon_device *rdev = dev->dev_private;
4041         uint32_t bios_2_scratch, bios_6_scratch;
4042
4043         if (rdev->family >= CHIP_R600) {
4044                 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
4045                 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
4046         } else {
4047                 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
4048                 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
4049         }
4050
4051         /* let the bios control the backlight */
4052         bios_2_scratch &= ~ATOM_S2_VRI_BRIGHT_ENABLE;
4053
4054         /* tell the bios not to handle mode switching */
4055         bios_6_scratch |= ATOM_S6_ACC_BLOCK_DISPLAY_SWITCH;
4056
4057         /* clear the vbios dpms state */
4058         if (ASIC_IS_DCE4(rdev))
4059                 bios_2_scratch &= ~ATOM_S2_DEVICE_DPMS_STATE;
4060
4061         if (rdev->family >= CHIP_R600) {
4062                 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
4063                 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
4064         } else {
4065                 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
4066                 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
4067         }
4068
4069 }
4070
4071 void radeon_save_bios_scratch_regs(struct radeon_device *rdev)
4072 {
4073         uint32_t scratch_reg;
4074         int i;
4075
4076         if (rdev->family >= CHIP_R600)
4077                 scratch_reg = R600_BIOS_0_SCRATCH;
4078         else
4079                 scratch_reg = RADEON_BIOS_0_SCRATCH;
4080
4081         for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
4082                 rdev->bios_scratch[i] = RREG32(scratch_reg + (i * 4));
4083 }
4084
4085 void radeon_restore_bios_scratch_regs(struct radeon_device *rdev)
4086 {
4087         uint32_t scratch_reg;
4088         int i;
4089
4090         if (rdev->family >= CHIP_R600)
4091                 scratch_reg = R600_BIOS_0_SCRATCH;
4092         else
4093                 scratch_reg = RADEON_BIOS_0_SCRATCH;
4094
4095         for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
4096                 WREG32(scratch_reg + (i * 4), rdev->bios_scratch[i]);
4097 }
4098
4099 void radeon_atom_output_lock(struct drm_encoder *encoder, bool lock)
4100 {
4101         struct drm_device *dev = encoder->dev;
4102         struct radeon_device *rdev = dev->dev_private;
4103         uint32_t bios_6_scratch;
4104
4105         if (rdev->family >= CHIP_R600)
4106                 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
4107         else
4108                 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
4109
4110         if (lock) {
4111                 bios_6_scratch |= ATOM_S6_CRITICAL_STATE;
4112                 bios_6_scratch &= ~ATOM_S6_ACC_MODE;
4113         } else {
4114                 bios_6_scratch &= ~ATOM_S6_CRITICAL_STATE;
4115                 bios_6_scratch |= ATOM_S6_ACC_MODE;
4116         }
4117
4118         if (rdev->family >= CHIP_R600)
4119                 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
4120         else
4121                 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
4122 }
4123
4124 /* at some point we may want to break this out into individual functions */
4125 void
4126 radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
4127                                        struct drm_encoder *encoder,
4128                                        bool connected)
4129 {
4130         struct drm_device *dev = connector->dev;
4131         struct radeon_device *rdev = dev->dev_private;
4132         struct radeon_connector *radeon_connector =
4133             to_radeon_connector(connector);
4134         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
4135         uint32_t bios_0_scratch, bios_3_scratch, bios_6_scratch;
4136
4137         if (rdev->family >= CHIP_R600) {
4138                 bios_0_scratch = RREG32(R600_BIOS_0_SCRATCH);
4139                 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
4140                 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
4141         } else {
4142                 bios_0_scratch = RREG32(RADEON_BIOS_0_SCRATCH);
4143                 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
4144                 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
4145         }
4146
4147         if ((radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) &&
4148             (radeon_connector->devices & ATOM_DEVICE_TV1_SUPPORT)) {
4149                 if (connected) {
4150                         DRM_DEBUG_KMS("TV1 connected\n");
4151                         bios_3_scratch |= ATOM_S3_TV1_ACTIVE;
4152                         bios_6_scratch |= ATOM_S6_ACC_REQ_TV1;
4153                 } else {
4154                         DRM_DEBUG_KMS("TV1 disconnected\n");
4155                         bios_0_scratch &= ~ATOM_S0_TV1_MASK;
4156                         bios_3_scratch &= ~ATOM_S3_TV1_ACTIVE;
4157                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_TV1;
4158                 }
4159         }
4160         if ((radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) &&
4161             (radeon_connector->devices & ATOM_DEVICE_CV_SUPPORT)) {
4162                 if (connected) {
4163                         DRM_DEBUG_KMS("CV connected\n");
4164                         bios_3_scratch |= ATOM_S3_CV_ACTIVE;
4165                         bios_6_scratch |= ATOM_S6_ACC_REQ_CV;
4166                 } else {
4167                         DRM_DEBUG_KMS("CV disconnected\n");
4168                         bios_0_scratch &= ~ATOM_S0_CV_MASK;
4169                         bios_3_scratch &= ~ATOM_S3_CV_ACTIVE;
4170                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_CV;
4171                 }
4172         }
4173         if ((radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) &&
4174             (radeon_connector->devices & ATOM_DEVICE_LCD1_SUPPORT)) {
4175                 if (connected) {
4176                         DRM_DEBUG_KMS("LCD1 connected\n");
4177                         bios_0_scratch |= ATOM_S0_LCD1;
4178                         bios_3_scratch |= ATOM_S3_LCD1_ACTIVE;
4179                         bios_6_scratch |= ATOM_S6_ACC_REQ_LCD1;
4180                 } else {
4181                         DRM_DEBUG_KMS("LCD1 disconnected\n");
4182                         bios_0_scratch &= ~ATOM_S0_LCD1;
4183                         bios_3_scratch &= ~ATOM_S3_LCD1_ACTIVE;
4184                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_LCD1;
4185                 }
4186         }
4187         if ((radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) &&
4188             (radeon_connector->devices & ATOM_DEVICE_CRT1_SUPPORT)) {
4189                 if (connected) {
4190                         DRM_DEBUG_KMS("CRT1 connected\n");
4191                         bios_0_scratch |= ATOM_S0_CRT1_COLOR;
4192                         bios_3_scratch |= ATOM_S3_CRT1_ACTIVE;
4193                         bios_6_scratch |= ATOM_S6_ACC_REQ_CRT1;
4194                 } else {
4195                         DRM_DEBUG_KMS("CRT1 disconnected\n");
4196                         bios_0_scratch &= ~ATOM_S0_CRT1_MASK;
4197                         bios_3_scratch &= ~ATOM_S3_CRT1_ACTIVE;
4198                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT1;
4199                 }
4200         }
4201         if ((radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) &&
4202             (radeon_connector->devices & ATOM_DEVICE_CRT2_SUPPORT)) {
4203                 if (connected) {
4204                         DRM_DEBUG_KMS("CRT2 connected\n");
4205                         bios_0_scratch |= ATOM_S0_CRT2_COLOR;
4206                         bios_3_scratch |= ATOM_S3_CRT2_ACTIVE;
4207                         bios_6_scratch |= ATOM_S6_ACC_REQ_CRT2;
4208                 } else {
4209                         DRM_DEBUG_KMS("CRT2 disconnected\n");
4210                         bios_0_scratch &= ~ATOM_S0_CRT2_MASK;
4211                         bios_3_scratch &= ~ATOM_S3_CRT2_ACTIVE;
4212                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT2;
4213                 }
4214         }
4215         if ((radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) &&
4216             (radeon_connector->devices & ATOM_DEVICE_DFP1_SUPPORT)) {
4217                 if (connected) {
4218                         DRM_DEBUG_KMS("DFP1 connected\n");
4219                         bios_0_scratch |= ATOM_S0_DFP1;
4220                         bios_3_scratch |= ATOM_S3_DFP1_ACTIVE;
4221                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP1;
4222                 } else {
4223                         DRM_DEBUG_KMS("DFP1 disconnected\n");
4224                         bios_0_scratch &= ~ATOM_S0_DFP1;
4225                         bios_3_scratch &= ~ATOM_S3_DFP1_ACTIVE;
4226                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP1;
4227                 }
4228         }
4229         if ((radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) &&
4230             (radeon_connector->devices & ATOM_DEVICE_DFP2_SUPPORT)) {
4231                 if (connected) {
4232                         DRM_DEBUG_KMS("DFP2 connected\n");
4233                         bios_0_scratch |= ATOM_S0_DFP2;
4234                         bios_3_scratch |= ATOM_S3_DFP2_ACTIVE;
4235                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP2;
4236                 } else {
4237                         DRM_DEBUG_KMS("DFP2 disconnected\n");
4238                         bios_0_scratch &= ~ATOM_S0_DFP2;
4239                         bios_3_scratch &= ~ATOM_S3_DFP2_ACTIVE;
4240                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP2;
4241                 }
4242         }
4243         if ((radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) &&
4244             (radeon_connector->devices & ATOM_DEVICE_DFP3_SUPPORT)) {
4245                 if (connected) {
4246                         DRM_DEBUG_KMS("DFP3 connected\n");
4247                         bios_0_scratch |= ATOM_S0_DFP3;
4248                         bios_3_scratch |= ATOM_S3_DFP3_ACTIVE;
4249                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP3;
4250                 } else {
4251                         DRM_DEBUG_KMS("DFP3 disconnected\n");
4252                         bios_0_scratch &= ~ATOM_S0_DFP3;
4253                         bios_3_scratch &= ~ATOM_S3_DFP3_ACTIVE;
4254                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP3;
4255                 }
4256         }
4257         if ((radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) &&
4258             (radeon_connector->devices & ATOM_DEVICE_DFP4_SUPPORT)) {
4259                 if (connected) {
4260                         DRM_DEBUG_KMS("DFP4 connected\n");
4261                         bios_0_scratch |= ATOM_S0_DFP4;
4262                         bios_3_scratch |= ATOM_S3_DFP4_ACTIVE;
4263                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP4;
4264                 } else {
4265                         DRM_DEBUG_KMS("DFP4 disconnected\n");
4266                         bios_0_scratch &= ~ATOM_S0_DFP4;
4267                         bios_3_scratch &= ~ATOM_S3_DFP4_ACTIVE;
4268                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP4;
4269                 }
4270         }
4271         if ((radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) &&
4272             (radeon_connector->devices & ATOM_DEVICE_DFP5_SUPPORT)) {
4273                 if (connected) {
4274                         DRM_DEBUG_KMS("DFP5 connected\n");
4275                         bios_0_scratch |= ATOM_S0_DFP5;
4276                         bios_3_scratch |= ATOM_S3_DFP5_ACTIVE;
4277                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP5;
4278                 } else {
4279                         DRM_DEBUG_KMS("DFP5 disconnected\n");
4280                         bios_0_scratch &= ~ATOM_S0_DFP5;
4281                         bios_3_scratch &= ~ATOM_S3_DFP5_ACTIVE;
4282                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP5;
4283                 }
4284         }
4285         if ((radeon_encoder->devices & ATOM_DEVICE_DFP6_SUPPORT) &&
4286             (radeon_connector->devices & ATOM_DEVICE_DFP6_SUPPORT)) {
4287                 if (connected) {
4288                         DRM_DEBUG_KMS("DFP6 connected\n");
4289                         bios_0_scratch |= ATOM_S0_DFP6;
4290                         bios_3_scratch |= ATOM_S3_DFP6_ACTIVE;
4291                         bios_6_scratch |= ATOM_S6_ACC_REQ_DFP6;
4292                 } else {
4293                         DRM_DEBUG_KMS("DFP6 disconnected\n");
4294                         bios_0_scratch &= ~ATOM_S0_DFP6;
4295                         bios_3_scratch &= ~ATOM_S3_DFP6_ACTIVE;
4296                         bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP6;
4297                 }
4298         }
4299
4300         if (rdev->family >= CHIP_R600) {
4301                 WREG32(R600_BIOS_0_SCRATCH, bios_0_scratch);
4302                 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
4303                 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
4304         } else {
4305                 WREG32(RADEON_BIOS_0_SCRATCH, bios_0_scratch);
4306                 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
4307                 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
4308         }
4309 }
4310
4311 void
4312 radeon_atombios_encoder_crtc_scratch_regs(struct drm_encoder *encoder, int crtc)
4313 {
4314         struct drm_device *dev = encoder->dev;
4315         struct radeon_device *rdev = dev->dev_private;
4316         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
4317         uint32_t bios_3_scratch;
4318
4319         if (ASIC_IS_DCE4(rdev))
4320                 return;
4321
4322         if (rdev->family >= CHIP_R600)
4323                 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
4324         else
4325                 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
4326
4327         if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
4328                 bios_3_scratch &= ~ATOM_S3_TV1_CRTC_ACTIVE;
4329                 bios_3_scratch |= (crtc << 18);
4330         }
4331         if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
4332                 bios_3_scratch &= ~ATOM_S3_CV_CRTC_ACTIVE;
4333                 bios_3_scratch |= (crtc << 24);
4334         }
4335         if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
4336                 bios_3_scratch &= ~ATOM_S3_CRT1_CRTC_ACTIVE;
4337                 bios_3_scratch |= (crtc << 16);
4338         }
4339         if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
4340                 bios_3_scratch &= ~ATOM_S3_CRT2_CRTC_ACTIVE;
4341                 bios_3_scratch |= (crtc << 20);
4342         }
4343         if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
4344                 bios_3_scratch &= ~ATOM_S3_LCD1_CRTC_ACTIVE;
4345                 bios_3_scratch |= (crtc << 17);
4346         }
4347         if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
4348                 bios_3_scratch &= ~ATOM_S3_DFP1_CRTC_ACTIVE;
4349                 bios_3_scratch |= (crtc << 19);
4350         }
4351         if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
4352                 bios_3_scratch &= ~ATOM_S3_DFP2_CRTC_ACTIVE;
4353                 bios_3_scratch |= (crtc << 23);
4354         }
4355         if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
4356                 bios_3_scratch &= ~ATOM_S3_DFP3_CRTC_ACTIVE;
4357                 bios_3_scratch |= (crtc << 25);
4358         }
4359
4360         if (rdev->family >= CHIP_R600)
4361                 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
4362         else
4363                 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
4364 }
4365
4366 void
4367 radeon_atombios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on)
4368 {
4369         struct drm_device *dev = encoder->dev;
4370         struct radeon_device *rdev = dev->dev_private;
4371         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
4372         uint32_t bios_2_scratch;
4373
4374         if (ASIC_IS_DCE4(rdev))
4375                 return;
4376
4377         if (rdev->family >= CHIP_R600)
4378                 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
4379         else
4380                 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
4381
4382         if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
4383                 if (on)
4384                         bios_2_scratch &= ~ATOM_S2_TV1_DPMS_STATE;
4385                 else
4386                         bios_2_scratch |= ATOM_S2_TV1_DPMS_STATE;
4387         }
4388         if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
4389                 if (on)
4390                         bios_2_scratch &= ~ATOM_S2_CV_DPMS_STATE;
4391                 else
4392                         bios_2_scratch |= ATOM_S2_CV_DPMS_STATE;
4393         }
4394         if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
4395                 if (on)
4396                         bios_2_scratch &= ~ATOM_S2_CRT1_DPMS_STATE;
4397                 else
4398                         bios_2_scratch |= ATOM_S2_CRT1_DPMS_STATE;
4399         }
4400         if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
4401                 if (on)
4402                         bios_2_scratch &= ~ATOM_S2_CRT2_DPMS_STATE;
4403                 else
4404                         bios_2_scratch |= ATOM_S2_CRT2_DPMS_STATE;
4405         }
4406         if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
4407                 if (on)
4408                         bios_2_scratch &= ~ATOM_S2_LCD1_DPMS_STATE;
4409                 else
4410                         bios_2_scratch |= ATOM_S2_LCD1_DPMS_STATE;
4411         }
4412         if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
4413                 if (on)
4414                         bios_2_scratch &= ~ATOM_S2_DFP1_DPMS_STATE;
4415                 else
4416                         bios_2_scratch |= ATOM_S2_DFP1_DPMS_STATE;
4417         }
4418         if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
4419                 if (on)
4420                         bios_2_scratch &= ~ATOM_S2_DFP2_DPMS_STATE;
4421                 else
4422                         bios_2_scratch |= ATOM_S2_DFP2_DPMS_STATE;
4423         }
4424         if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
4425                 if (on)
4426                         bios_2_scratch &= ~ATOM_S2_DFP3_DPMS_STATE;
4427                 else
4428                         bios_2_scratch |= ATOM_S2_DFP3_DPMS_STATE;
4429         }
4430         if (radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) {
4431                 if (on)
4432                         bios_2_scratch &= ~ATOM_S2_DFP4_DPMS_STATE;
4433                 else
4434                         bios_2_scratch |= ATOM_S2_DFP4_DPMS_STATE;
4435         }
4436         if (radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) {
4437                 if (on)
4438                         bios_2_scratch &= ~ATOM_S2_DFP5_DPMS_STATE;
4439                 else
4440                         bios_2_scratch |= ATOM_S2_DFP5_DPMS_STATE;
4441         }
4442
4443         if (rdev->family >= CHIP_R600)
4444                 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
4445         else
4446                 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
4447 }