1 /* 2 * Copyright 2008 Advanced Micro Devices, Inc. 3 * Copyright 2008 Red Hat Inc. 4 * Copyright 2009 Jerome Glisse. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: Dave Airlie 25 * Alex Deucher 26 * Jerome Glisse 27 */ 28 29 #include <linux/console.h> 30 #include <linux/efi.h> 31 #include <linux/pci.h> 32 #include <linux/pm_runtime.h> 33 #include <linux/slab.h> 34 #include <linux/vga_switcheroo.h> 35 #include <linux/vgaarb.h> 36 37 #include <drm/drm_cache.h> 38 #include <drm/drm_client_event.h> 39 #include <drm/drm_crtc_helper.h> 40 #include <drm/drm_device.h> 41 #include <drm/drm_file.h> 42 #include <drm/drm_framebuffer.h> 43 #include <drm/drm_probe_helper.h> 44 #include <drm/radeon_drm.h> 45 46 #include "radeon_device.h" 47 #include "radeon_reg.h" 48 #include "radeon.h" 49 #include "atom.h" 50 51 static const char radeon_family_name[][16] = { 52 "R100", 53 "RV100", 54 "RS100", 55 "RV200", 56 "RS200", 57 "R200", 58 "RV250", 59 "RS300", 60 "RV280", 61 "R300", 62 "R350", 63 "RV350", 64 "RV380", 65 "R420", 66 "R423", 67 "RV410", 68 "RS400", 69 "RS480", 70 "RS600", 71 "RS690", 72 "RS740", 73 "RV515", 74 "R520", 75 "RV530", 76 "RV560", 77 "RV570", 78 "R580", 79 "R600", 80 "RV610", 81 "RV630", 82 "RV670", 83 "RV620", 84 "RV635", 85 "RS780", 86 "RS880", 87 "RV770", 88 "RV730", 89 "RV710", 90 "RV740", 91 "CEDAR", 92 "REDWOOD", 93 "JUNIPER", 94 "CYPRESS", 95 "HEMLOCK", 96 "PALM", 97 "SUMO", 98 "SUMO2", 99 "BARTS", 100 "TURKS", 101 "CAICOS", 102 "CAYMAN", 103 "ARUBA", 104 "TAHITI", 105 "PITCAIRN", 106 "VERDE", 107 "OLAND", 108 "HAINAN", 109 "BONAIRE", 110 "KAVERI", 111 "KABINI", 112 "HAWAII", 113 "MULLINS", 114 "LAST", 115 }; 116 117 #if defined(CONFIG_VGA_SWITCHEROO) 118 bool radeon_has_atpx_dgpu_power_cntl(void); 119 bool radeon_is_atpx_hybrid(void); 120 #else 121 static inline bool radeon_has_atpx_dgpu_power_cntl(void) { return false; } 122 static inline bool radeon_is_atpx_hybrid(void) { return false; } 123 #endif 124 125 #define RADEON_PX_QUIRK_DISABLE_PX (1 << 0) 126 127 struct radeon_px_quirk { 128 u32 chip_vendor; 129 u32 chip_device; 130 u32 subsys_vendor; 131 u32 subsys_device; 132 u32 px_quirk_flags; 133 }; 134 135 static struct radeon_px_quirk radeon_px_quirk_list[] = { 136 /* Acer aspire 5560g (CPU: AMD A4-3305M; GPU: AMD Radeon HD 6480g + 7470m) 137 * https://bugzilla.kernel.org/show_bug.cgi?id=74551 138 */ 139 { PCI_VENDOR_ID_ATI, 0x6760, 0x1025, 0x0672, RADEON_PX_QUIRK_DISABLE_PX }, 140 /* Asus K73TA laptop with AMD A6-3400M APU and Radeon 6550 GPU 141 * https://bugzilla.kernel.org/show_bug.cgi?id=51381 142 */ 143 { PCI_VENDOR_ID_ATI, 0x6741, 0x1043, 0x108c, RADEON_PX_QUIRK_DISABLE_PX }, 144 /* Asus K53TK laptop with AMD A6-3420M APU and Radeon 7670m GPU 145 * https://bugzilla.kernel.org/show_bug.cgi?id=51381 146 */ 147 { PCI_VENDOR_ID_ATI, 0x6840, 0x1043, 0x2122, RADEON_PX_QUIRK_DISABLE_PX }, 148 /* Asus K53TK laptop with AMD A6-3420M APU and Radeon 7670m GPU 149 * https://bugs.freedesktop.org/show_bug.cgi?id=101491 150 */ 151 { PCI_VENDOR_ID_ATI, 0x6741, 0x1043, 0x2122, RADEON_PX_QUIRK_DISABLE_PX }, 152 /* Asus K73TK laptop with AMD A6-3420M APU and Radeon 7670m GPU 153 * https://bugzilla.kernel.org/show_bug.cgi?id=51381#c52 154 */ 155 { PCI_VENDOR_ID_ATI, 0x6840, 0x1043, 0x2123, RADEON_PX_QUIRK_DISABLE_PX }, 156 { 0, 0, 0, 0, 0 }, 157 }; 158 159 bool radeon_is_px(struct drm_device *dev) 160 { 161 struct radeon_device *rdev = dev->dev_private; 162 163 if (rdev->flags & RADEON_IS_PX) 164 return true; 165 return false; 166 } 167 168 static void radeon_device_handle_px_quirks(struct radeon_device *rdev) 169 { 170 struct radeon_px_quirk *p = radeon_px_quirk_list; 171 172 /* Apply PX quirks */ 173 while (p && p->chip_device != 0) { 174 if (rdev->pdev->vendor == p->chip_vendor && 175 rdev->pdev->device == p->chip_device && 176 rdev->pdev->subsystem_vendor == p->subsys_vendor && 177 rdev->pdev->subsystem_device == p->subsys_device) { 178 rdev->px_quirk_flags = p->px_quirk_flags; 179 break; 180 } 181 ++p; 182 } 183 184 if (rdev->px_quirk_flags & RADEON_PX_QUIRK_DISABLE_PX) 185 rdev->flags &= ~RADEON_IS_PX; 186 187 /* disable PX is the system doesn't support dGPU power control or hybrid gfx */ 188 if (!radeon_is_atpx_hybrid() && 189 !radeon_has_atpx_dgpu_power_cntl()) 190 rdev->flags &= ~RADEON_IS_PX; 191 } 192 193 /** 194 * radeon_program_register_sequence - program an array of registers. 195 * 196 * @rdev: radeon_device pointer 197 * @registers: pointer to the register array 198 * @array_size: size of the register array 199 * 200 * Programs an array or registers with and and or masks. 201 * This is a helper for setting golden registers. 202 */ 203 void radeon_program_register_sequence(struct radeon_device *rdev, 204 const u32 *registers, 205 const u32 array_size) 206 { 207 u32 tmp, reg, and_mask, or_mask; 208 int i; 209 210 if (array_size % 3) 211 return; 212 213 for (i = 0; i < array_size; i +=3) { 214 reg = registers[i + 0]; 215 and_mask = registers[i + 1]; 216 or_mask = registers[i + 2]; 217 218 if (and_mask == 0xffffffff) { 219 tmp = or_mask; 220 } else { 221 tmp = RREG32(reg); 222 tmp &= ~and_mask; 223 tmp |= or_mask; 224 } 225 WREG32(reg, tmp); 226 } 227 } 228 229 void radeon_pci_config_reset(struct radeon_device *rdev) 230 { 231 pci_write_config_dword(rdev->pdev, 0x7c, RADEON_ASIC_RESET_DATA); 232 } 233 234 /** 235 * radeon_surface_init - Clear GPU surface registers. 236 * 237 * @rdev: radeon_device pointer 238 * 239 * Clear GPU surface registers (r1xx-r5xx). 240 */ 241 void radeon_surface_init(struct radeon_device *rdev) 242 { 243 /* FIXME: check this out */ 244 if (rdev->family < CHIP_R600) { 245 int i; 246 247 for (i = 0; i < RADEON_GEM_MAX_SURFACES; i++) { 248 if (rdev->surface_regs[i].bo) 249 radeon_bo_get_surface_reg(rdev->surface_regs[i].bo); 250 else 251 radeon_clear_surface_reg(rdev, i); 252 } 253 /* enable surfaces */ 254 WREG32(RADEON_SURFACE_CNTL, 0); 255 } 256 } 257 258 /* 259 * GPU scratch registers helpers function. 260 */ 261 /** 262 * radeon_scratch_init - Init scratch register driver information. 263 * 264 * @rdev: radeon_device pointer 265 * 266 * Init CP scratch register driver information (r1xx-r5xx) 267 */ 268 void radeon_scratch_init(struct radeon_device *rdev) 269 { 270 int i; 271 272 /* FIXME: check this out */ 273 if (rdev->family < CHIP_R300) { 274 rdev->scratch.num_reg = 5; 275 } else { 276 rdev->scratch.num_reg = 7; 277 } 278 rdev->scratch.reg_base = RADEON_SCRATCH_REG0; 279 for (i = 0; i < rdev->scratch.num_reg; i++) { 280 rdev->scratch.free[i] = true; 281 rdev->scratch.reg[i] = rdev->scratch.reg_base + (i * 4); 282 } 283 } 284 285 /** 286 * radeon_scratch_get - Allocate a scratch register 287 * 288 * @rdev: radeon_device pointer 289 * @reg: scratch register mmio offset 290 * 291 * Allocate a CP scratch register for use by the driver (all asics). 292 * Returns 0 on success or -EINVAL on failure. 293 */ 294 int radeon_scratch_get(struct radeon_device *rdev, uint32_t *reg) 295 { 296 int i; 297 298 for (i = 0; i < rdev->scratch.num_reg; i++) { 299 if (rdev->scratch.free[i]) { 300 rdev->scratch.free[i] = false; 301 *reg = rdev->scratch.reg[i]; 302 return 0; 303 } 304 } 305 return -EINVAL; 306 } 307 308 /** 309 * radeon_scratch_free - Free a scratch register 310 * 311 * @rdev: radeon_device pointer 312 * @reg: scratch register mmio offset 313 * 314 * Free a CP scratch register allocated for use by the driver (all asics) 315 */ 316 void radeon_scratch_free(struct radeon_device *rdev, uint32_t reg) 317 { 318 int i; 319 320 for (i = 0; i < rdev->scratch.num_reg; i++) { 321 if (rdev->scratch.reg[i] == reg) { 322 rdev->scratch.free[i] = true; 323 return; 324 } 325 } 326 } 327 328 /* 329 * GPU doorbell aperture helpers function. 330 */ 331 /** 332 * radeon_doorbell_init - Init doorbell driver information. 333 * 334 * @rdev: radeon_device pointer 335 * 336 * Init doorbell driver information (CIK) 337 * Returns 0 on success, error on failure. 338 */ 339 static int radeon_doorbell_init(struct radeon_device *rdev) 340 { 341 /* doorbell bar mapping */ 342 rdev->doorbell.base = pci_resource_start(rdev->pdev, 2); 343 rdev->doorbell.size = pci_resource_len(rdev->pdev, 2); 344 345 rdev->doorbell.num_doorbells = min_t(u32, rdev->doorbell.size / sizeof(u32), RADEON_MAX_DOORBELLS); 346 if (rdev->doorbell.num_doorbells == 0) 347 return -EINVAL; 348 349 rdev->doorbell.ptr = ioremap(rdev->doorbell.base, rdev->doorbell.num_doorbells * sizeof(u32)); 350 if (rdev->doorbell.ptr == NULL) { 351 return -ENOMEM; 352 } 353 DRM_INFO("doorbell mmio base: 0x%08X\n", (uint32_t)rdev->doorbell.base); 354 DRM_INFO("doorbell mmio size: %u\n", (unsigned)rdev->doorbell.size); 355 356 memset(&rdev->doorbell.used, 0, sizeof(rdev->doorbell.used)); 357 358 return 0; 359 } 360 361 /** 362 * radeon_doorbell_fini - Tear down doorbell driver information. 363 * 364 * @rdev: radeon_device pointer 365 * 366 * Tear down doorbell driver information (CIK) 367 */ 368 static void radeon_doorbell_fini(struct radeon_device *rdev) 369 { 370 iounmap(rdev->doorbell.ptr); 371 rdev->doorbell.ptr = NULL; 372 } 373 374 /** 375 * radeon_doorbell_get - Allocate a doorbell entry 376 * 377 * @rdev: radeon_device pointer 378 * @doorbell: doorbell index 379 * 380 * Allocate a doorbell for use by the driver (all asics). 381 * Returns 0 on success or -EINVAL on failure. 382 */ 383 int radeon_doorbell_get(struct radeon_device *rdev, u32 *doorbell) 384 { 385 unsigned long offset = find_first_zero_bit(rdev->doorbell.used, rdev->doorbell.num_doorbells); 386 if (offset < rdev->doorbell.num_doorbells) { 387 __set_bit(offset, rdev->doorbell.used); 388 *doorbell = offset; 389 return 0; 390 } else { 391 return -EINVAL; 392 } 393 } 394 395 /** 396 * radeon_doorbell_free - Free a doorbell entry 397 * 398 * @rdev: radeon_device pointer 399 * @doorbell: doorbell index 400 * 401 * Free a doorbell allocated for use by the driver (all asics) 402 */ 403 void radeon_doorbell_free(struct radeon_device *rdev, u32 doorbell) 404 { 405 if (doorbell < rdev->doorbell.num_doorbells) 406 __clear_bit(doorbell, rdev->doorbell.used); 407 } 408 409 /* 410 * radeon_wb_*() 411 * Writeback is the method by which the GPU updates special pages 412 * in memory with the status of certain GPU events (fences, ring pointers, 413 * etc.). 414 */ 415 416 /** 417 * radeon_wb_disable - Disable Writeback 418 * 419 * @rdev: radeon_device pointer 420 * 421 * Disables Writeback (all asics). Used for suspend. 422 */ 423 void radeon_wb_disable(struct radeon_device *rdev) 424 { 425 rdev->wb.enabled = false; 426 } 427 428 /** 429 * radeon_wb_fini - Disable Writeback and free memory 430 * 431 * @rdev: radeon_device pointer 432 * 433 * Disables Writeback and frees the Writeback memory (all asics). 434 * Used at driver shutdown. 435 */ 436 void radeon_wb_fini(struct radeon_device *rdev) 437 { 438 radeon_wb_disable(rdev); 439 if (rdev->wb.wb_obj) { 440 if (!radeon_bo_reserve(rdev->wb.wb_obj, false)) { 441 radeon_bo_kunmap(rdev->wb.wb_obj); 442 radeon_bo_unpin(rdev->wb.wb_obj); 443 radeon_bo_unreserve(rdev->wb.wb_obj); 444 } 445 radeon_bo_unref(&rdev->wb.wb_obj); 446 rdev->wb.wb = NULL; 447 rdev->wb.wb_obj = NULL; 448 } 449 } 450 451 /** 452 * radeon_wb_init- Init Writeback driver info and allocate memory 453 * 454 * @rdev: radeon_device pointer 455 * 456 * Disables Writeback and frees the Writeback memory (all asics). 457 * Used at driver startup. 458 * Returns 0 on success or an -error on failure. 459 */ 460 int radeon_wb_init(struct radeon_device *rdev) 461 { 462 int r; 463 464 if (rdev->wb.wb_obj == NULL) { 465 r = radeon_bo_create(rdev, RADEON_GPU_PAGE_SIZE, PAGE_SIZE, true, 466 RADEON_GEM_DOMAIN_GTT, 0, NULL, NULL, 467 &rdev->wb.wb_obj); 468 if (r) { 469 dev_warn(rdev->dev, "(%d) create WB bo failed\n", r); 470 return r; 471 } 472 r = radeon_bo_reserve(rdev->wb.wb_obj, false); 473 if (unlikely(r != 0)) { 474 radeon_wb_fini(rdev); 475 return r; 476 } 477 r = radeon_bo_pin(rdev->wb.wb_obj, RADEON_GEM_DOMAIN_GTT, 478 &rdev->wb.gpu_addr); 479 if (r) { 480 radeon_bo_unreserve(rdev->wb.wb_obj); 481 dev_warn(rdev->dev, "(%d) pin WB bo failed\n", r); 482 radeon_wb_fini(rdev); 483 return r; 484 } 485 r = radeon_bo_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb); 486 radeon_bo_unreserve(rdev->wb.wb_obj); 487 if (r) { 488 dev_warn(rdev->dev, "(%d) map WB bo failed\n", r); 489 radeon_wb_fini(rdev); 490 return r; 491 } 492 } 493 494 /* clear wb memory */ 495 memset((char *)rdev->wb.wb, 0, RADEON_GPU_PAGE_SIZE); 496 /* disable event_write fences */ 497 rdev->wb.use_event = false; 498 /* disabled via module param */ 499 if (radeon_no_wb == 1) { 500 rdev->wb.enabled = false; 501 } else { 502 if (rdev->flags & RADEON_IS_AGP) { 503 /* often unreliable on AGP */ 504 rdev->wb.enabled = false; 505 } else if (rdev->family < CHIP_R300) { 506 /* often unreliable on pre-r300 */ 507 rdev->wb.enabled = false; 508 } else { 509 rdev->wb.enabled = true; 510 /* event_write fences are only available on r600+ */ 511 if (rdev->family >= CHIP_R600) { 512 rdev->wb.use_event = true; 513 } 514 } 515 } 516 /* always use writeback/events on NI, APUs */ 517 if (rdev->family >= CHIP_PALM) { 518 rdev->wb.enabled = true; 519 rdev->wb.use_event = true; 520 } 521 522 dev_info(rdev->dev, "WB %sabled\n", rdev->wb.enabled ? "en" : "dis"); 523 524 return 0; 525 } 526 527 /** 528 * radeon_vram_location - try to find VRAM location 529 * @rdev: radeon device structure holding all necessary informations 530 * @mc: memory controller structure holding memory informations 531 * @base: base address at which to put VRAM 532 * 533 * Function will place try to place VRAM at base address provided 534 * as parameter (which is so far either PCI aperture address or 535 * for IGP TOM base address). 536 * 537 * If there is not enough space to fit the unvisible VRAM in the 32bits 538 * address space then we limit the VRAM size to the aperture. 539 * 540 * If we are using AGP and if the AGP aperture doesn't allow us to have 541 * room for all the VRAM than we restrict the VRAM to the PCI aperture 542 * size and print a warning. 543 * 544 * This function will never fails, worst case are limiting VRAM. 545 * 546 * Note: GTT start, end, size should be initialized before calling this 547 * function on AGP platform. 548 * 549 * Note 1: We don't explicitly enforce VRAM start to be aligned on VRAM size, 550 * this shouldn't be a problem as we are using the PCI aperture as a reference. 551 * Otherwise this would be needed for rv280, all r3xx, and all r4xx, but 552 * not IGP. 553 * 554 * Note 2: we use mc_vram_size as on some board we need to program the mc to 555 * cover the whole aperture even if VRAM size is inferior to aperture size 556 * Novell bug 204882 + along with lots of ubuntu ones 557 * 558 * Note 3: when limiting vram it's safe to overwritte real_vram_size because 559 * we are not in case where real_vram_size is inferior to mc_vram_size (ie 560 * note afected by bogus hw of Novell bug 204882 + along with lots of ubuntu 561 * ones) 562 * 563 * Note 4: IGP TOM addr should be the same as the aperture addr, we don't 564 * explicitly check for that thought. 565 * 566 * FIXME: when reducing VRAM size align new size on power of 2. 567 */ 568 void radeon_vram_location(struct radeon_device *rdev, struct radeon_mc *mc, u64 base) 569 { 570 uint64_t limit = (uint64_t)radeon_vram_limit << 20; 571 572 mc->vram_start = base; 573 if (mc->mc_vram_size > (rdev->mc.mc_mask - base + 1)) { 574 dev_warn(rdev->dev, "limiting VRAM to PCI aperture size\n"); 575 mc->real_vram_size = mc->aper_size; 576 mc->mc_vram_size = mc->aper_size; 577 } 578 mc->vram_end = mc->vram_start + mc->mc_vram_size - 1; 579 if (rdev->flags & RADEON_IS_AGP && mc->vram_end > mc->gtt_start && mc->vram_start <= mc->gtt_end) { 580 dev_warn(rdev->dev, "limiting VRAM to PCI aperture size\n"); 581 mc->real_vram_size = mc->aper_size; 582 mc->mc_vram_size = mc->aper_size; 583 } 584 mc->vram_end = mc->vram_start + mc->mc_vram_size - 1; 585 if (limit && limit < mc->real_vram_size) 586 mc->real_vram_size = limit; 587 dev_info(rdev->dev, "VRAM: %lluM 0x%016llX - 0x%016llX (%lluM used)\n", 588 mc->mc_vram_size >> 20, mc->vram_start, 589 mc->vram_end, mc->real_vram_size >> 20); 590 } 591 592 /** 593 * radeon_gtt_location - try to find GTT location 594 * @rdev: radeon device structure holding all necessary informations 595 * @mc: memory controller structure holding memory informations 596 * 597 * Function will place try to place GTT before or after VRAM. 598 * 599 * If GTT size is bigger than space left then we ajust GTT size. 600 * Thus function will never fails. 601 * 602 * FIXME: when reducing GTT size align new size on power of 2. 603 */ 604 void radeon_gtt_location(struct radeon_device *rdev, struct radeon_mc *mc) 605 { 606 u64 size_af, size_bf; 607 608 size_af = ((rdev->mc.mc_mask - mc->vram_end) + mc->gtt_base_align) & ~mc->gtt_base_align; 609 size_bf = mc->vram_start & ~mc->gtt_base_align; 610 if (size_bf > size_af) { 611 if (mc->gtt_size > size_bf) { 612 dev_warn(rdev->dev, "limiting GTT\n"); 613 mc->gtt_size = size_bf; 614 } 615 mc->gtt_start = (mc->vram_start & ~mc->gtt_base_align) - mc->gtt_size; 616 } else { 617 if (mc->gtt_size > size_af) { 618 dev_warn(rdev->dev, "limiting GTT\n"); 619 mc->gtt_size = size_af; 620 } 621 mc->gtt_start = (mc->vram_end + 1 + mc->gtt_base_align) & ~mc->gtt_base_align; 622 } 623 mc->gtt_end = mc->gtt_start + mc->gtt_size - 1; 624 dev_info(rdev->dev, "GTT: %lluM 0x%016llX - 0x%016llX\n", 625 mc->gtt_size >> 20, mc->gtt_start, mc->gtt_end); 626 } 627 628 /* 629 * GPU helpers function. 630 */ 631 632 /* 633 * radeon_device_is_virtual - check if we are running is a virtual environment 634 * 635 * Check if the asic has been passed through to a VM (all asics). 636 * Used at driver startup. 637 * Returns true if virtual or false if not. 638 */ 639 bool radeon_device_is_virtual(void) 640 { 641 #ifdef CONFIG_X86 642 return boot_cpu_has(X86_FEATURE_HYPERVISOR); 643 #else 644 return false; 645 #endif 646 } 647 648 /** 649 * radeon_card_posted - check if the hw has already been initialized 650 * 651 * @rdev: radeon_device pointer 652 * 653 * Check if the asic has been initialized (all asics). 654 * Used at driver startup. 655 * Returns true if initialized or false if not. 656 */ 657 bool radeon_card_posted(struct radeon_device *rdev) 658 { 659 uint32_t reg; 660 661 /* for pass through, always force asic_init for CI */ 662 if (rdev->family >= CHIP_BONAIRE && 663 radeon_device_is_virtual()) 664 return false; 665 666 /* required for EFI mode on macbook2,1 which uses an r5xx asic */ 667 if (efi_enabled(EFI_BOOT) && 668 (rdev->pdev->subsystem_vendor == PCI_VENDOR_ID_APPLE) && 669 (rdev->family < CHIP_R600)) 670 return false; 671 672 if (ASIC_IS_NODCE(rdev)) 673 goto check_memsize; 674 675 /* first check CRTCs */ 676 if (ASIC_IS_DCE4(rdev)) { 677 reg = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET) | 678 RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET); 679 if (rdev->num_crtc >= 4) { 680 reg |= RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC2_REGISTER_OFFSET) | 681 RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC3_REGISTER_OFFSET); 682 } 683 if (rdev->num_crtc >= 6) { 684 reg |= RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC4_REGISTER_OFFSET) | 685 RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC5_REGISTER_OFFSET); 686 } 687 if (reg & EVERGREEN_CRTC_MASTER_EN) 688 return true; 689 } else if (ASIC_IS_AVIVO(rdev)) { 690 reg = RREG32(AVIVO_D1CRTC_CONTROL) | 691 RREG32(AVIVO_D2CRTC_CONTROL); 692 if (reg & AVIVO_CRTC_EN) { 693 return true; 694 } 695 } else { 696 reg = RREG32(RADEON_CRTC_GEN_CNTL) | 697 RREG32(RADEON_CRTC2_GEN_CNTL); 698 if (reg & RADEON_CRTC_EN) { 699 return true; 700 } 701 } 702 703 check_memsize: 704 /* then check MEM_SIZE, in case the crtcs are off */ 705 if (rdev->family >= CHIP_R600) 706 reg = RREG32(R600_CONFIG_MEMSIZE); 707 else 708 reg = RREG32(RADEON_CONFIG_MEMSIZE); 709 710 if (reg) 711 return true; 712 713 return false; 714 715 } 716 717 /** 718 * radeon_update_bandwidth_info - update display bandwidth params 719 * 720 * @rdev: radeon_device pointer 721 * 722 * Used when sclk/mclk are switched or display modes are set. 723 * params are used to calculate display watermarks (all asics) 724 */ 725 void radeon_update_bandwidth_info(struct radeon_device *rdev) 726 { 727 fixed20_12 a; 728 u32 sclk = rdev->pm.current_sclk; 729 u32 mclk = rdev->pm.current_mclk; 730 731 /* sclk/mclk in Mhz */ 732 a.full = dfixed_const(100); 733 rdev->pm.sclk.full = dfixed_const(sclk); 734 rdev->pm.sclk.full = dfixed_div(rdev->pm.sclk, a); 735 rdev->pm.mclk.full = dfixed_const(mclk); 736 rdev->pm.mclk.full = dfixed_div(rdev->pm.mclk, a); 737 738 if (rdev->flags & RADEON_IS_IGP) { 739 a.full = dfixed_const(16); 740 /* core_bandwidth = sclk(Mhz) * 16 */ 741 rdev->pm.core_bandwidth.full = dfixed_div(rdev->pm.sclk, a); 742 } 743 } 744 745 /** 746 * radeon_boot_test_post_card - check and possibly initialize the hw 747 * 748 * @rdev: radeon_device pointer 749 * 750 * Check if the asic is initialized and if not, attempt to initialize 751 * it (all asics). 752 * Returns true if initialized or false if not. 753 */ 754 bool radeon_boot_test_post_card(struct radeon_device *rdev) 755 { 756 if (radeon_card_posted(rdev)) 757 return true; 758 759 if (rdev->bios) { 760 DRM_INFO("GPU not posted. posting now...\n"); 761 if (rdev->is_atom_bios) 762 atom_asic_init(rdev->mode_info.atom_context); 763 else 764 radeon_combios_asic_init(rdev_to_drm(rdev)); 765 return true; 766 } else { 767 dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n"); 768 return false; 769 } 770 } 771 772 /** 773 * radeon_dummy_page_init - init dummy page used by the driver 774 * 775 * @rdev: radeon_device pointer 776 * 777 * Allocate the dummy page used by the driver (all asics). 778 * This dummy page is used by the driver as a filler for gart entries 779 * when pages are taken out of the GART 780 * Returns 0 on sucess, -ENOMEM on failure. 781 */ 782 int radeon_dummy_page_init(struct radeon_device *rdev) 783 { 784 if (rdev->dummy_page.page) 785 return 0; 786 rdev->dummy_page.page = alloc_page(GFP_DMA32 | GFP_KERNEL | __GFP_ZERO); 787 if (rdev->dummy_page.page == NULL) 788 return -ENOMEM; 789 rdev->dummy_page.addr = dma_map_page(&rdev->pdev->dev, rdev->dummy_page.page, 790 0, PAGE_SIZE, DMA_BIDIRECTIONAL); 791 if (dma_mapping_error(&rdev->pdev->dev, rdev->dummy_page.addr)) { 792 dev_err(&rdev->pdev->dev, "Failed to DMA MAP the dummy page\n"); 793 __free_page(rdev->dummy_page.page); 794 rdev->dummy_page.page = NULL; 795 return -ENOMEM; 796 } 797 rdev->dummy_page.entry = radeon_gart_get_page_entry(rdev->dummy_page.addr, 798 RADEON_GART_PAGE_DUMMY); 799 return 0; 800 } 801 802 /** 803 * radeon_dummy_page_fini - free dummy page used by the driver 804 * 805 * @rdev: radeon_device pointer 806 * 807 * Frees the dummy page used by the driver (all asics). 808 */ 809 void radeon_dummy_page_fini(struct radeon_device *rdev) 810 { 811 if (rdev->dummy_page.page == NULL) 812 return; 813 dma_unmap_page(&rdev->pdev->dev, rdev->dummy_page.addr, PAGE_SIZE, 814 DMA_BIDIRECTIONAL); 815 __free_page(rdev->dummy_page.page); 816 rdev->dummy_page.page = NULL; 817 } 818 819 820 /* ATOM accessor methods */ 821 /* 822 * ATOM is an interpreted byte code stored in tables in the vbios. The 823 * driver registers callbacks to access registers and the interpreter 824 * in the driver parses the tables and executes then to program specific 825 * actions (set display modes, asic init, etc.). See radeon_atombios.c, 826 * atombios.h, and atom.c 827 */ 828 829 /** 830 * cail_pll_read - read PLL register 831 * 832 * @info: atom card_info pointer 833 * @reg: PLL register offset 834 * 835 * Provides a PLL register accessor for the atom interpreter (r4xx+). 836 * Returns the value of the PLL register. 837 */ 838 static uint32_t cail_pll_read(struct card_info *info, uint32_t reg) 839 { 840 struct radeon_device *rdev = info->dev->dev_private; 841 uint32_t r; 842 843 r = rdev->pll_rreg(rdev, reg); 844 return r; 845 } 846 847 /** 848 * cail_pll_write - write PLL register 849 * 850 * @info: atom card_info pointer 851 * @reg: PLL register offset 852 * @val: value to write to the pll register 853 * 854 * Provides a PLL register accessor for the atom interpreter (r4xx+). 855 */ 856 static void cail_pll_write(struct card_info *info, uint32_t reg, uint32_t val) 857 { 858 struct radeon_device *rdev = info->dev->dev_private; 859 860 rdev->pll_wreg(rdev, reg, val); 861 } 862 863 /** 864 * cail_mc_read - read MC (Memory Controller) register 865 * 866 * @info: atom card_info pointer 867 * @reg: MC register offset 868 * 869 * Provides an MC register accessor for the atom interpreter (r4xx+). 870 * Returns the value of the MC register. 871 */ 872 static uint32_t cail_mc_read(struct card_info *info, uint32_t reg) 873 { 874 struct radeon_device *rdev = info->dev->dev_private; 875 uint32_t r; 876 877 r = rdev->mc_rreg(rdev, reg); 878 return r; 879 } 880 881 /** 882 * cail_mc_write - write MC (Memory Controller) register 883 * 884 * @info: atom card_info pointer 885 * @reg: MC register offset 886 * @val: value to write to the pll register 887 * 888 * Provides a MC register accessor for the atom interpreter (r4xx+). 889 */ 890 static void cail_mc_write(struct card_info *info, uint32_t reg, uint32_t val) 891 { 892 struct radeon_device *rdev = info->dev->dev_private; 893 894 rdev->mc_wreg(rdev, reg, val); 895 } 896 897 /** 898 * cail_reg_write - write MMIO register 899 * 900 * @info: atom card_info pointer 901 * @reg: MMIO register offset 902 * @val: value to write to the pll register 903 * 904 * Provides a MMIO register accessor for the atom interpreter (r4xx+). 905 */ 906 static void cail_reg_write(struct card_info *info, uint32_t reg, uint32_t val) 907 { 908 struct radeon_device *rdev = info->dev->dev_private; 909 910 WREG32(reg*4, val); 911 } 912 913 /** 914 * cail_reg_read - read MMIO register 915 * 916 * @info: atom card_info pointer 917 * @reg: MMIO register offset 918 * 919 * Provides an MMIO register accessor for the atom interpreter (r4xx+). 920 * Returns the value of the MMIO register. 921 */ 922 static uint32_t cail_reg_read(struct card_info *info, uint32_t reg) 923 { 924 struct radeon_device *rdev = info->dev->dev_private; 925 uint32_t r; 926 927 r = RREG32(reg*4); 928 return r; 929 } 930 931 /** 932 * cail_ioreg_write - write IO register 933 * 934 * @info: atom card_info pointer 935 * @reg: IO register offset 936 * @val: value to write to the pll register 937 * 938 * Provides a IO register accessor for the atom interpreter (r4xx+). 939 */ 940 static void cail_ioreg_write(struct card_info *info, uint32_t reg, uint32_t val) 941 { 942 struct radeon_device *rdev = info->dev->dev_private; 943 944 WREG32_IO(reg*4, val); 945 } 946 947 /** 948 * cail_ioreg_read - read IO register 949 * 950 * @info: atom card_info pointer 951 * @reg: IO register offset 952 * 953 * Provides an IO register accessor for the atom interpreter (r4xx+). 954 * Returns the value of the IO register. 955 */ 956 static uint32_t cail_ioreg_read(struct card_info *info, uint32_t reg) 957 { 958 struct radeon_device *rdev = info->dev->dev_private; 959 uint32_t r; 960 961 r = RREG32_IO(reg*4); 962 return r; 963 } 964 965 /** 966 * radeon_atombios_init - init the driver info and callbacks for atombios 967 * 968 * @rdev: radeon_device pointer 969 * 970 * Initializes the driver info and register access callbacks for the 971 * ATOM interpreter (r4xx+). 972 * Returns 0 on sucess, -ENOMEM on failure. 973 * Called at driver startup. 974 */ 975 int radeon_atombios_init(struct radeon_device *rdev) 976 { 977 struct card_info *atom_card_info = 978 kzalloc(sizeof(struct card_info), GFP_KERNEL); 979 980 if (!atom_card_info) 981 return -ENOMEM; 982 983 rdev->mode_info.atom_card_info = atom_card_info; 984 atom_card_info->dev = rdev_to_drm(rdev); 985 atom_card_info->reg_read = cail_reg_read; 986 atom_card_info->reg_write = cail_reg_write; 987 /* needed for iio ops */ 988 if (rdev->rio_mem) { 989 atom_card_info->ioreg_read = cail_ioreg_read; 990 atom_card_info->ioreg_write = cail_ioreg_write; 991 } else { 992 DRM_ERROR("Unable to find PCI I/O BAR; using MMIO for ATOM IIO\n"); 993 atom_card_info->ioreg_read = cail_reg_read; 994 atom_card_info->ioreg_write = cail_reg_write; 995 } 996 atom_card_info->mc_read = cail_mc_read; 997 atom_card_info->mc_write = cail_mc_write; 998 atom_card_info->pll_read = cail_pll_read; 999 atom_card_info->pll_write = cail_pll_write; 1000 1001 rdev->mode_info.atom_context = atom_parse(atom_card_info, rdev->bios); 1002 if (!rdev->mode_info.atom_context) { 1003 radeon_atombios_fini(rdev); 1004 return -ENOMEM; 1005 } 1006 1007 mutex_init(&rdev->mode_info.atom_context->mutex); 1008 mutex_init(&rdev->mode_info.atom_context->scratch_mutex); 1009 radeon_atom_initialize_bios_scratch_regs(rdev_to_drm(rdev)); 1010 atom_allocate_fb_scratch(rdev->mode_info.atom_context); 1011 return 0; 1012 } 1013 1014 /** 1015 * radeon_atombios_fini - free the driver info and callbacks for atombios 1016 * 1017 * @rdev: radeon_device pointer 1018 * 1019 * Frees the driver info and register access callbacks for the ATOM 1020 * interpreter (r4xx+). 1021 * Called at driver shutdown. 1022 */ 1023 void radeon_atombios_fini(struct radeon_device *rdev) 1024 { 1025 if (rdev->mode_info.atom_context) { 1026 kfree(rdev->mode_info.atom_context->scratch); 1027 kfree(rdev->mode_info.atom_context->iio); 1028 } 1029 kfree(rdev->mode_info.atom_context); 1030 rdev->mode_info.atom_context = NULL; 1031 kfree(rdev->mode_info.atom_card_info); 1032 rdev->mode_info.atom_card_info = NULL; 1033 } 1034 1035 /* COMBIOS */ 1036 /* 1037 * COMBIOS is the bios format prior to ATOM. It provides 1038 * command tables similar to ATOM, but doesn't have a unified 1039 * parser. See radeon_combios.c 1040 */ 1041 1042 /** 1043 * radeon_combios_init - init the driver info for combios 1044 * 1045 * @rdev: radeon_device pointer 1046 * 1047 * Initializes the driver info for combios (r1xx-r3xx). 1048 * Returns 0 on sucess. 1049 * Called at driver startup. 1050 */ 1051 int radeon_combios_init(struct radeon_device *rdev) 1052 { 1053 radeon_combios_initialize_bios_scratch_regs(rdev_to_drm(rdev)); 1054 return 0; 1055 } 1056 1057 /** 1058 * radeon_combios_fini - free the driver info for combios 1059 * 1060 * @rdev: radeon_device pointer 1061 * 1062 * Frees the driver info for combios (r1xx-r3xx). 1063 * Called at driver shutdown. 1064 */ 1065 void radeon_combios_fini(struct radeon_device *rdev) 1066 { 1067 } 1068 1069 /* if we get transitioned to only one device, take VGA back */ 1070 /** 1071 * radeon_vga_set_decode - enable/disable vga decode 1072 * 1073 * @pdev: PCI device 1074 * @state: enable/disable vga decode 1075 * 1076 * Enable/disable vga decode (all asics). 1077 * Returns VGA resource flags. 1078 */ 1079 static unsigned int radeon_vga_set_decode(struct pci_dev *pdev, bool state) 1080 { 1081 struct drm_device *dev = pci_get_drvdata(pdev); 1082 struct radeon_device *rdev = dev->dev_private; 1083 radeon_vga_set_state(rdev, state); 1084 if (state) 1085 return VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM | 1086 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM; 1087 else 1088 return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM; 1089 } 1090 1091 /** 1092 * radeon_gart_size_auto - Determine a sensible default GART size 1093 * according to ASIC family. 1094 * 1095 * @family: ASIC family name 1096 */ 1097 static int radeon_gart_size_auto(enum radeon_family family) 1098 { 1099 /* default to a larger gart size on newer asics */ 1100 if (family >= CHIP_TAHITI) 1101 return 2048; 1102 else if (family >= CHIP_RV770) 1103 return 1024; 1104 else 1105 return 512; 1106 } 1107 1108 /** 1109 * radeon_check_arguments - validate module params 1110 * 1111 * @rdev: radeon_device pointer 1112 * 1113 * Validates certain module parameters and updates 1114 * the associated values used by the driver (all asics). 1115 */ 1116 static void radeon_check_arguments(struct radeon_device *rdev) 1117 { 1118 /* vramlimit must be a power of two */ 1119 if (radeon_vram_limit != 0 && !is_power_of_2(radeon_vram_limit)) { 1120 dev_warn(rdev->dev, "vram limit (%d) must be a power of 2\n", 1121 radeon_vram_limit); 1122 radeon_vram_limit = 0; 1123 } 1124 1125 if (radeon_gart_size == -1) { 1126 radeon_gart_size = radeon_gart_size_auto(rdev->family); 1127 } 1128 /* gtt size must be power of two and greater or equal to 32M */ 1129 if (radeon_gart_size < 32) { 1130 dev_warn(rdev->dev, "gart size (%d) too small\n", 1131 radeon_gart_size); 1132 radeon_gart_size = radeon_gart_size_auto(rdev->family); 1133 } else if (!is_power_of_2(radeon_gart_size)) { 1134 dev_warn(rdev->dev, "gart size (%d) must be a power of 2\n", 1135 radeon_gart_size); 1136 radeon_gart_size = radeon_gart_size_auto(rdev->family); 1137 } 1138 rdev->mc.gtt_size = (uint64_t)radeon_gart_size << 20; 1139 1140 /* AGP mode can only be -1, 1, 2, 4, 8 */ 1141 switch (radeon_agpmode) { 1142 case -1: 1143 case 0: 1144 case 1: 1145 case 2: 1146 case 4: 1147 case 8: 1148 break; 1149 default: 1150 dev_warn(rdev->dev, "invalid AGP mode %d (valid mode: " 1151 "-1, 0, 1, 2, 4, 8)\n", radeon_agpmode); 1152 radeon_agpmode = 0; 1153 break; 1154 } 1155 1156 if (!is_power_of_2(radeon_vm_size)) { 1157 dev_warn(rdev->dev, "VM size (%d) must be a power of 2\n", 1158 radeon_vm_size); 1159 radeon_vm_size = 4; 1160 } 1161 1162 if (radeon_vm_size < 1) { 1163 dev_warn(rdev->dev, "VM size (%d) too small, min is 1GB\n", 1164 radeon_vm_size); 1165 radeon_vm_size = 4; 1166 } 1167 1168 /* 1169 * Max GPUVM size for Cayman, SI and CI are 40 bits. 1170 */ 1171 if (radeon_vm_size > 1024) { 1172 dev_warn(rdev->dev, "VM size (%d) too large, max is 1TB\n", 1173 radeon_vm_size); 1174 radeon_vm_size = 4; 1175 } 1176 1177 /* defines number of bits in page table versus page directory, 1178 * a page is 4KB so we have 12 bits offset, minimum 9 bits in the 1179 * page table and the remaining bits are in the page directory */ 1180 if (radeon_vm_block_size == -1) { 1181 1182 /* Total bits covered by PD + PTs */ 1183 unsigned bits = ilog2(radeon_vm_size) + 18; 1184 1185 /* Make sure the PD is 4K in size up to 8GB address space. 1186 Above that split equal between PD and PTs */ 1187 if (radeon_vm_size <= 8) 1188 radeon_vm_block_size = bits - 9; 1189 else 1190 radeon_vm_block_size = (bits + 3) / 2; 1191 1192 } else if (radeon_vm_block_size < 9) { 1193 dev_warn(rdev->dev, "VM page table size (%d) too small\n", 1194 radeon_vm_block_size); 1195 radeon_vm_block_size = 9; 1196 } 1197 1198 if (radeon_vm_block_size > 24 || 1199 (radeon_vm_size * 1024) < (1ull << radeon_vm_block_size)) { 1200 dev_warn(rdev->dev, "VM page table size (%d) too large\n", 1201 radeon_vm_block_size); 1202 radeon_vm_block_size = 9; 1203 } 1204 } 1205 1206 /** 1207 * radeon_switcheroo_set_state - set switcheroo state 1208 * 1209 * @pdev: pci dev pointer 1210 * @state: vga_switcheroo state 1211 * 1212 * Callback for the switcheroo driver. Suspends or resumes 1213 * the asics before or after it is powered up using ACPI methods. 1214 */ 1215 static void radeon_switcheroo_set_state(struct pci_dev *pdev, enum vga_switcheroo_state state) 1216 { 1217 struct drm_device *dev = pci_get_drvdata(pdev); 1218 1219 if (radeon_is_px(dev) && state == VGA_SWITCHEROO_OFF) 1220 return; 1221 1222 if (state == VGA_SWITCHEROO_ON) { 1223 pr_info("radeon: switched on\n"); 1224 /* don't suspend or resume card normally */ 1225 dev->switch_power_state = DRM_SWITCH_POWER_CHANGING; 1226 1227 radeon_resume_kms(dev, true, true); 1228 1229 dev->switch_power_state = DRM_SWITCH_POWER_ON; 1230 drm_kms_helper_poll_enable(dev); 1231 } else { 1232 pr_info("radeon: switched off\n"); 1233 drm_kms_helper_poll_disable(dev); 1234 dev->switch_power_state = DRM_SWITCH_POWER_CHANGING; 1235 radeon_suspend_kms(dev, true, true, false); 1236 dev->switch_power_state = DRM_SWITCH_POWER_OFF; 1237 } 1238 } 1239 1240 /** 1241 * radeon_switcheroo_can_switch - see if switcheroo state can change 1242 * 1243 * @pdev: pci dev pointer 1244 * 1245 * Callback for the switcheroo driver. Check of the switcheroo 1246 * state can be changed. 1247 * Returns true if the state can be changed, false if not. 1248 */ 1249 static bool radeon_switcheroo_can_switch(struct pci_dev *pdev) 1250 { 1251 struct drm_device *dev = pci_get_drvdata(pdev); 1252 1253 /* 1254 * FIXME: open_count is protected by drm_global_mutex but that would lead to 1255 * locking inversion with the driver load path. And the access here is 1256 * completely racy anyway. So don't bother with locking for now. 1257 */ 1258 return atomic_read(&dev->open_count) == 0; 1259 } 1260 1261 static const struct vga_switcheroo_client_ops radeon_switcheroo_ops = { 1262 .set_gpu_state = radeon_switcheroo_set_state, 1263 .reprobe = NULL, 1264 .can_switch = radeon_switcheroo_can_switch, 1265 }; 1266 1267 /** 1268 * radeon_device_init - initialize the driver 1269 * 1270 * @rdev: radeon_device pointer 1271 * @ddev: drm dev pointer 1272 * @pdev: pci dev pointer 1273 * @flags: driver flags 1274 * 1275 * Initializes the driver info and hw (all asics). 1276 * Returns 0 for success or an error on failure. 1277 * Called at driver startup. 1278 */ 1279 int radeon_device_init(struct radeon_device *rdev, 1280 struct drm_device *ddev, 1281 struct pci_dev *pdev, 1282 uint32_t flags) 1283 { 1284 int r, i; 1285 int dma_bits; 1286 bool runtime = false; 1287 1288 rdev->shutdown = false; 1289 rdev->flags = flags; 1290 rdev->family = flags & RADEON_FAMILY_MASK; 1291 rdev->is_atom_bios = false; 1292 rdev->usec_timeout = RADEON_MAX_USEC_TIMEOUT; 1293 rdev->mc.gtt_size = 512 * 1024 * 1024; 1294 rdev->accel_working = false; 1295 /* set up ring ids */ 1296 for (i = 0; i < RADEON_NUM_RINGS; i++) { 1297 rdev->ring[i].idx = i; 1298 } 1299 rdev->fence_context = dma_fence_context_alloc(RADEON_NUM_RINGS); 1300 1301 DRM_INFO("initializing kernel modesetting (%s 0x%04X:0x%04X 0x%04X:0x%04X 0x%02X).\n", 1302 radeon_family_name[rdev->family], pdev->vendor, pdev->device, 1303 pdev->subsystem_vendor, pdev->subsystem_device, pdev->revision); 1304 1305 /* mutex initialization are all done here so we 1306 * can recall function without having locking issues */ 1307 mutex_init(&rdev->ring_lock); 1308 mutex_init(&rdev->dc_hw_i2c_mutex); 1309 atomic_set(&rdev->ih.lock, 0); 1310 mutex_init(&rdev->gem.mutex); 1311 mutex_init(&rdev->pm.mutex); 1312 mutex_init(&rdev->gpu_clock_mutex); 1313 mutex_init(&rdev->srbm_mutex); 1314 mutex_init(&rdev->audio.component_mutex); 1315 init_rwsem(&rdev->pm.mclk_lock); 1316 init_rwsem(&rdev->exclusive_lock); 1317 init_waitqueue_head(&rdev->irq.vblank_queue); 1318 r = radeon_gem_init(rdev); 1319 if (r) 1320 return r; 1321 1322 radeon_check_arguments(rdev); 1323 /* Adjust VM size here. 1324 * Max GPUVM size for cayman+ is 40 bits. 1325 */ 1326 rdev->vm_manager.max_pfn = radeon_vm_size << 18; 1327 1328 /* Set asic functions */ 1329 r = radeon_asic_init(rdev); 1330 if (r) 1331 return r; 1332 1333 /* all of the newer IGP chips have an internal gart 1334 * However some rs4xx report as AGP, so remove that here. 1335 */ 1336 if ((rdev->family >= CHIP_RS400) && 1337 (rdev->flags & RADEON_IS_IGP)) { 1338 rdev->flags &= ~RADEON_IS_AGP; 1339 } 1340 1341 if (rdev->flags & RADEON_IS_AGP && radeon_agpmode == -1) { 1342 radeon_agp_disable(rdev); 1343 } 1344 1345 /* Set the internal MC address mask 1346 * This is the max address of the GPU's 1347 * internal address space. 1348 */ 1349 if (rdev->family >= CHIP_CAYMAN) 1350 rdev->mc.mc_mask = 0xffffffffffULL; /* 40 bit MC */ 1351 else if (rdev->family >= CHIP_CEDAR) 1352 rdev->mc.mc_mask = 0xfffffffffULL; /* 36 bit MC */ 1353 else 1354 rdev->mc.mc_mask = 0xffffffffULL; /* 32 bit MC */ 1355 1356 /* set DMA mask. 1357 * PCIE - can handle 40-bits. 1358 * IGP - can handle 40-bits 1359 * AGP - generally dma32 is safest 1360 * PCI - dma32 for legacy pci gart, 40 bits on newer asics 1361 */ 1362 dma_bits = 40; 1363 if (rdev->flags & RADEON_IS_AGP) 1364 dma_bits = 32; 1365 if ((rdev->flags & RADEON_IS_PCI) && 1366 (rdev->family <= CHIP_RS740)) 1367 dma_bits = 32; 1368 #ifdef CONFIG_PPC64 1369 if (rdev->family == CHIP_CEDAR) 1370 dma_bits = 32; 1371 #endif 1372 1373 r = dma_set_mask_and_coherent(&rdev->pdev->dev, DMA_BIT_MASK(dma_bits)); 1374 if (r) { 1375 pr_warn("radeon: No suitable DMA available\n"); 1376 return r; 1377 } 1378 rdev->need_swiotlb = drm_need_swiotlb(dma_bits); 1379 1380 /* Registers mapping */ 1381 /* TODO: block userspace mapping of io register */ 1382 spin_lock_init(&rdev->mmio_idx_lock); 1383 spin_lock_init(&rdev->smc_idx_lock); 1384 spin_lock_init(&rdev->pll_idx_lock); 1385 spin_lock_init(&rdev->mc_idx_lock); 1386 spin_lock_init(&rdev->pcie_idx_lock); 1387 spin_lock_init(&rdev->pciep_idx_lock); 1388 spin_lock_init(&rdev->pif_idx_lock); 1389 spin_lock_init(&rdev->cg_idx_lock); 1390 spin_lock_init(&rdev->uvd_idx_lock); 1391 spin_lock_init(&rdev->rcu_idx_lock); 1392 spin_lock_init(&rdev->didt_idx_lock); 1393 spin_lock_init(&rdev->end_idx_lock); 1394 if (rdev->family >= CHIP_BONAIRE) { 1395 rdev->rmmio_base = pci_resource_start(rdev->pdev, 5); 1396 rdev->rmmio_size = pci_resource_len(rdev->pdev, 5); 1397 } else { 1398 rdev->rmmio_base = pci_resource_start(rdev->pdev, 2); 1399 rdev->rmmio_size = pci_resource_len(rdev->pdev, 2); 1400 } 1401 rdev->rmmio = ioremap(rdev->rmmio_base, rdev->rmmio_size); 1402 if (rdev->rmmio == NULL) 1403 return -ENOMEM; 1404 1405 /* doorbell bar mapping */ 1406 if (rdev->family >= CHIP_BONAIRE) 1407 radeon_doorbell_init(rdev); 1408 1409 /* io port mapping */ 1410 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { 1411 if (pci_resource_flags(rdev->pdev, i) & IORESOURCE_IO) { 1412 rdev->rio_mem_size = pci_resource_len(rdev->pdev, i); 1413 rdev->rio_mem = pci_iomap(rdev->pdev, i, rdev->rio_mem_size); 1414 break; 1415 } 1416 } 1417 if (rdev->rio_mem == NULL) 1418 DRM_ERROR("Unable to find PCI I/O BAR\n"); 1419 1420 if (rdev->flags & RADEON_IS_PX) 1421 radeon_device_handle_px_quirks(rdev); 1422 1423 /* if we have > 1 VGA cards, then disable the radeon VGA resources */ 1424 /* this will fail for cards that aren't VGA class devices, just 1425 * ignore it */ 1426 vga_client_register(rdev->pdev, radeon_vga_set_decode); 1427 1428 if (rdev->flags & RADEON_IS_PX) 1429 runtime = true; 1430 if (!pci_is_thunderbolt_attached(rdev->pdev)) 1431 vga_switcheroo_register_client(rdev->pdev, 1432 &radeon_switcheroo_ops, runtime); 1433 if (runtime) 1434 vga_switcheroo_init_domain_pm_ops(rdev->dev, &rdev->vga_pm_domain); 1435 1436 r = radeon_init(rdev); 1437 if (r) 1438 goto failed; 1439 1440 radeon_gem_debugfs_init(rdev); 1441 1442 if (rdev->flags & RADEON_IS_AGP && !rdev->accel_working) { 1443 /* Acceleration not working on AGP card try again 1444 * with fallback to PCI or PCIE GART 1445 */ 1446 radeon_asic_reset(rdev); 1447 radeon_fini(rdev); 1448 radeon_agp_disable(rdev); 1449 r = radeon_init(rdev); 1450 if (r) 1451 goto failed; 1452 } 1453 1454 radeon_audio_component_init(rdev); 1455 1456 r = radeon_ib_ring_tests(rdev); 1457 if (r) 1458 DRM_ERROR("ib ring test failed (%d).\n", r); 1459 1460 /* 1461 * Turks/Thames GPU will freeze whole laptop if DPM is not restarted 1462 * after the CP ring have chew one packet at least. Hence here we stop 1463 * and restart DPM after the radeon_ib_ring_tests(). 1464 */ 1465 if (rdev->pm.dpm_enabled && 1466 (rdev->pm.pm_method == PM_METHOD_DPM) && 1467 (rdev->family == CHIP_TURKS) && 1468 (rdev->flags & RADEON_IS_MOBILITY)) { 1469 mutex_lock(&rdev->pm.mutex); 1470 radeon_dpm_disable(rdev); 1471 radeon_dpm_enable(rdev); 1472 mutex_unlock(&rdev->pm.mutex); 1473 } 1474 1475 if ((radeon_testing & 1)) { 1476 if (rdev->accel_working) 1477 radeon_test_moves(rdev); 1478 else 1479 DRM_INFO("radeon: acceleration disabled, skipping move tests\n"); 1480 } 1481 if ((radeon_testing & 2)) { 1482 if (rdev->accel_working) 1483 radeon_test_syncing(rdev); 1484 else 1485 DRM_INFO("radeon: acceleration disabled, skipping sync tests\n"); 1486 } 1487 if (radeon_benchmarking) { 1488 if (rdev->accel_working) 1489 radeon_benchmark(rdev, radeon_benchmarking); 1490 else 1491 DRM_INFO("radeon: acceleration disabled, skipping benchmarks\n"); 1492 } 1493 return 0; 1494 1495 failed: 1496 /* balance pm_runtime_get_sync() in radeon_driver_unload_kms() */ 1497 if (radeon_is_px(ddev)) 1498 pm_runtime_put_noidle(ddev->dev); 1499 if (runtime) 1500 vga_switcheroo_fini_domain_pm_ops(rdev->dev); 1501 return r; 1502 } 1503 1504 /** 1505 * radeon_device_fini - tear down the driver 1506 * 1507 * @rdev: radeon_device pointer 1508 * 1509 * Tear down the driver info (all asics). 1510 * Called at driver shutdown. 1511 */ 1512 void radeon_device_fini(struct radeon_device *rdev) 1513 { 1514 DRM_INFO("radeon: finishing device.\n"); 1515 rdev->shutdown = true; 1516 /* evict vram memory */ 1517 radeon_bo_evict_vram(rdev); 1518 radeon_audio_component_fini(rdev); 1519 radeon_fini(rdev); 1520 if (!pci_is_thunderbolt_attached(rdev->pdev)) 1521 vga_switcheroo_unregister_client(rdev->pdev); 1522 if (rdev->flags & RADEON_IS_PX) 1523 vga_switcheroo_fini_domain_pm_ops(rdev->dev); 1524 vga_client_unregister(rdev->pdev); 1525 if (rdev->rio_mem) 1526 pci_iounmap(rdev->pdev, rdev->rio_mem); 1527 rdev->rio_mem = NULL; 1528 iounmap(rdev->rmmio); 1529 rdev->rmmio = NULL; 1530 if (rdev->family >= CHIP_BONAIRE) 1531 radeon_doorbell_fini(rdev); 1532 } 1533 1534 1535 /* 1536 * Suspend & resume. 1537 */ 1538 /* 1539 * radeon_suspend_kms - initiate device suspend 1540 * 1541 * Puts the hw in the suspend state (all asics). 1542 * Returns 0 for success or an error on failure. 1543 * Called at driver suspend. 1544 */ 1545 int radeon_suspend_kms(struct drm_device *dev, bool suspend, 1546 bool notify_clients, bool freeze) 1547 { 1548 struct radeon_device *rdev; 1549 struct pci_dev *pdev; 1550 struct drm_crtc *crtc; 1551 struct drm_connector *connector; 1552 int i, r; 1553 1554 if (dev == NULL || dev->dev_private == NULL) { 1555 return -ENODEV; 1556 } 1557 1558 rdev = dev->dev_private; 1559 pdev = to_pci_dev(dev->dev); 1560 1561 if (dev->switch_power_state == DRM_SWITCH_POWER_OFF) 1562 return 0; 1563 1564 drm_kms_helper_poll_disable(dev); 1565 1566 drm_modeset_lock_all(dev); 1567 /* turn off display hw */ 1568 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1569 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF); 1570 } 1571 drm_modeset_unlock_all(dev); 1572 1573 /* unpin the front buffers and cursors */ 1574 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 1575 struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); 1576 struct drm_framebuffer *fb = crtc->primary->fb; 1577 struct radeon_bo *robj; 1578 1579 if (radeon_crtc->cursor_bo) { 1580 struct radeon_bo *robj = gem_to_radeon_bo(radeon_crtc->cursor_bo); 1581 r = radeon_bo_reserve(robj, false); 1582 if (r == 0) { 1583 radeon_bo_unpin(robj); 1584 radeon_bo_unreserve(robj); 1585 } 1586 } 1587 1588 if (fb == NULL || fb->obj[0] == NULL) { 1589 continue; 1590 } 1591 robj = gem_to_radeon_bo(fb->obj[0]); 1592 /* don't unpin kernel fb objects */ 1593 if (!radeon_fbdev_robj_is_fb(rdev, robj)) { 1594 r = radeon_bo_reserve(robj, false); 1595 if (r == 0) { 1596 radeon_bo_unpin(robj); 1597 radeon_bo_unreserve(robj); 1598 } 1599 } 1600 } 1601 /* evict vram memory */ 1602 radeon_bo_evict_vram(rdev); 1603 1604 /* wait for gpu to finish processing current batch */ 1605 for (i = 0; i < RADEON_NUM_RINGS; i++) { 1606 r = radeon_fence_wait_empty(rdev, i); 1607 if (r) { 1608 /* delay GPU reset to resume */ 1609 radeon_fence_driver_force_completion(rdev, i); 1610 } else { 1611 /* finish executing delayed work */ 1612 flush_delayed_work(&rdev->fence_drv[i].lockup_work); 1613 } 1614 } 1615 1616 radeon_save_bios_scratch_regs(rdev); 1617 1618 radeon_suspend(rdev); 1619 radeon_hpd_fini(rdev); 1620 /* evict remaining vram memory 1621 * This second call to evict vram is to evict the gart page table 1622 * using the CPU. 1623 */ 1624 radeon_bo_evict_vram(rdev); 1625 1626 radeon_agp_suspend(rdev); 1627 1628 pci_save_state(pdev); 1629 if (freeze && rdev->family >= CHIP_CEDAR && !(rdev->flags & RADEON_IS_IGP)) { 1630 rdev->asic->asic_reset(rdev, true); 1631 pci_restore_state(pdev); 1632 } else if (suspend) { 1633 /* Shut down the device */ 1634 pci_disable_device(pdev); 1635 pci_set_power_state(pdev, PCI_D3hot); 1636 } 1637 1638 if (notify_clients) { 1639 console_lock(); 1640 drm_client_dev_suspend(dev, true); 1641 console_unlock(); 1642 } 1643 return 0; 1644 } 1645 1646 /* 1647 * radeon_resume_kms - initiate device resume 1648 * 1649 * Bring the hw back to operating state (all asics). 1650 * Returns 0 for success or an error on failure. 1651 * Called at driver resume. 1652 */ 1653 int radeon_resume_kms(struct drm_device *dev, bool resume, bool notify_clients) 1654 { 1655 struct drm_connector *connector; 1656 struct radeon_device *rdev = dev->dev_private; 1657 struct pci_dev *pdev = to_pci_dev(dev->dev); 1658 struct drm_crtc *crtc; 1659 int r; 1660 1661 if (dev->switch_power_state == DRM_SWITCH_POWER_OFF) 1662 return 0; 1663 1664 if (notify_clients) { 1665 console_lock(); 1666 } 1667 if (resume) { 1668 pci_set_power_state(pdev, PCI_D0); 1669 pci_restore_state(pdev); 1670 if (pci_enable_device(pdev)) { 1671 if (notify_clients) 1672 console_unlock(); 1673 return -1; 1674 } 1675 } 1676 /* resume AGP if in use */ 1677 radeon_agp_resume(rdev); 1678 radeon_resume(rdev); 1679 1680 r = radeon_ib_ring_tests(rdev); 1681 if (r) 1682 DRM_ERROR("ib ring test failed (%d).\n", r); 1683 1684 if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) { 1685 /* do dpm late init */ 1686 r = radeon_pm_late_init(rdev); 1687 if (r) { 1688 rdev->pm.dpm_enabled = false; 1689 DRM_ERROR("radeon_pm_late_init failed, disabling dpm\n"); 1690 } 1691 } else { 1692 /* resume old pm late */ 1693 radeon_pm_resume(rdev); 1694 } 1695 1696 radeon_restore_bios_scratch_regs(rdev); 1697 1698 /* pin cursors */ 1699 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 1700 struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); 1701 1702 if (radeon_crtc->cursor_bo) { 1703 struct radeon_bo *robj = gem_to_radeon_bo(radeon_crtc->cursor_bo); 1704 r = radeon_bo_reserve(robj, false); 1705 if (r == 0) { 1706 /* Only 27 bit offset for legacy cursor */ 1707 r = radeon_bo_pin_restricted(robj, 1708 RADEON_GEM_DOMAIN_VRAM, 1709 ASIC_IS_AVIVO(rdev) ? 1710 0 : 1 << 27, 1711 &radeon_crtc->cursor_addr); 1712 if (r != 0) 1713 DRM_ERROR("Failed to pin cursor BO (%d)\n", r); 1714 radeon_bo_unreserve(robj); 1715 } 1716 } 1717 } 1718 1719 /* init dig PHYs, disp eng pll */ 1720 if (rdev->is_atom_bios) { 1721 radeon_atom_encoder_init(rdev); 1722 radeon_atom_disp_eng_pll_init(rdev); 1723 /* turn on the BL */ 1724 if (rdev->mode_info.bl_encoder) { 1725 u8 bl_level = radeon_get_backlight_level(rdev, 1726 rdev->mode_info.bl_encoder); 1727 radeon_set_backlight_level(rdev, rdev->mode_info.bl_encoder, 1728 bl_level); 1729 } 1730 } 1731 /* reset hpd state */ 1732 radeon_hpd_init(rdev); 1733 /* blat the mode back in */ 1734 if (notify_clients) { 1735 drm_helper_resume_force_mode(dev); 1736 /* turn on display hw */ 1737 drm_modeset_lock_all(dev); 1738 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1739 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON); 1740 } 1741 drm_modeset_unlock_all(dev); 1742 } 1743 1744 drm_kms_helper_poll_enable(dev); 1745 1746 /* set the power state here in case we are a PX system or headless */ 1747 if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) 1748 radeon_pm_compute_clocks(rdev); 1749 1750 if (notify_clients) { 1751 drm_client_dev_resume(dev, true); 1752 console_unlock(); 1753 } 1754 1755 return 0; 1756 } 1757 1758 /** 1759 * radeon_gpu_reset - reset the asic 1760 * 1761 * @rdev: radeon device pointer 1762 * 1763 * Attempt the reset the GPU if it has hung (all asics). 1764 * Returns 0 for success or an error on failure. 1765 */ 1766 int radeon_gpu_reset(struct radeon_device *rdev) 1767 { 1768 unsigned ring_sizes[RADEON_NUM_RINGS]; 1769 uint32_t *ring_data[RADEON_NUM_RINGS]; 1770 1771 bool saved = false; 1772 1773 int i, r; 1774 1775 down_write(&rdev->exclusive_lock); 1776 1777 if (!rdev->needs_reset) { 1778 up_write(&rdev->exclusive_lock); 1779 return 0; 1780 } 1781 1782 atomic_inc(&rdev->gpu_reset_counter); 1783 1784 radeon_save_bios_scratch_regs(rdev); 1785 radeon_suspend(rdev); 1786 radeon_hpd_fini(rdev); 1787 1788 for (i = 0; i < RADEON_NUM_RINGS; ++i) { 1789 ring_sizes[i] = radeon_ring_backup(rdev, &rdev->ring[i], 1790 &ring_data[i]); 1791 if (ring_sizes[i]) { 1792 saved = true; 1793 dev_info(rdev->dev, "Saved %d dwords of commands " 1794 "on ring %d.\n", ring_sizes[i], i); 1795 } 1796 } 1797 1798 r = radeon_asic_reset(rdev); 1799 if (!r) { 1800 dev_info(rdev->dev, "GPU reset succeeded, trying to resume\n"); 1801 radeon_resume(rdev); 1802 } 1803 1804 radeon_restore_bios_scratch_regs(rdev); 1805 1806 for (i = 0; i < RADEON_NUM_RINGS; ++i) { 1807 if (!r && ring_data[i]) { 1808 radeon_ring_restore(rdev, &rdev->ring[i], 1809 ring_sizes[i], ring_data[i]); 1810 } else { 1811 radeon_fence_driver_force_completion(rdev, i); 1812 kfree(ring_data[i]); 1813 } 1814 } 1815 1816 if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) { 1817 /* do dpm late init */ 1818 r = radeon_pm_late_init(rdev); 1819 if (r) { 1820 rdev->pm.dpm_enabled = false; 1821 DRM_ERROR("radeon_pm_late_init failed, disabling dpm\n"); 1822 } 1823 } else { 1824 /* resume old pm late */ 1825 radeon_pm_resume(rdev); 1826 } 1827 1828 /* init dig PHYs, disp eng pll */ 1829 if (rdev->is_atom_bios) { 1830 radeon_atom_encoder_init(rdev); 1831 radeon_atom_disp_eng_pll_init(rdev); 1832 /* turn on the BL */ 1833 if (rdev->mode_info.bl_encoder) { 1834 u8 bl_level = radeon_get_backlight_level(rdev, 1835 rdev->mode_info.bl_encoder); 1836 radeon_set_backlight_level(rdev, rdev->mode_info.bl_encoder, 1837 bl_level); 1838 } 1839 } 1840 /* reset hpd state */ 1841 radeon_hpd_init(rdev); 1842 1843 rdev->in_reset = true; 1844 rdev->needs_reset = false; 1845 1846 downgrade_write(&rdev->exclusive_lock); 1847 1848 drm_helper_resume_force_mode(rdev_to_drm(rdev)); 1849 1850 /* set the power state here in case we are a PX system or headless */ 1851 if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) 1852 radeon_pm_compute_clocks(rdev); 1853 1854 if (!r) { 1855 r = radeon_ib_ring_tests(rdev); 1856 if (r && saved) 1857 r = -EAGAIN; 1858 } else { 1859 /* bad news, how to tell it to userspace ? */ 1860 dev_info(rdev->dev, "GPU reset failed\n"); 1861 } 1862 1863 rdev->needs_reset = r == -EAGAIN; 1864 rdev->in_reset = false; 1865 1866 up_read(&rdev->exclusive_lock); 1867 return r; 1868 } 1869