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