1 /* 2 * Copyright © 2008-2012 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 * 23 * Authors: 24 * Eric Anholt <eric@anholt.net> 25 * Chris Wilson <chris@chris-wilson.co.uk> 26 * 27 */ 28 29 #include <drm/drmP.h> 30 #include <drm/i915_drm.h> 31 #include "i915_drv.h" 32 33 #define KB(x) ((x) * 1024) 34 #define MB(x) (KB(x) * 1024) 35 36 /* 37 * The BIOS typically reserves some of the system's memory for the exclusive 38 * use of the integrated graphics. This memory is no longer available for 39 * use by the OS and so the user finds that his system has less memory 40 * available than he put in. We refer to this memory as stolen. 41 * 42 * The BIOS will allocate its framebuffer from the stolen memory. Our 43 * goal is try to reuse that object for our own fbcon which must always 44 * be available for panics. Anything else we can reuse the stolen memory 45 * for is a boon. 46 */ 47 48 int i915_gem_stolen_insert_node_in_range(struct drm_i915_private *dev_priv, 49 struct drm_mm_node *node, u64 size, 50 unsigned alignment, u64 start, u64 end) 51 { 52 int ret; 53 54 if (!drm_mm_initialized(&dev_priv->mm.stolen)) 55 return -ENODEV; 56 57 /* See the comment at the drm_mm_init() call for more about this check. 58 * WaSkipStolenMemoryFirstPage:bdw,chv,kbl (incomplete) 59 */ 60 if (start < 4096 && (IS_GEN8(dev_priv) || 61 IS_KBL_REVID(dev_priv, 0, KBL_REVID_A0))) 62 start = 4096; 63 64 mutex_lock(&dev_priv->mm.stolen_lock); 65 ret = drm_mm_insert_node_in_range(&dev_priv->mm.stolen, node, size, 66 alignment, start, end, 67 DRM_MM_SEARCH_DEFAULT); 68 mutex_unlock(&dev_priv->mm.stolen_lock); 69 70 return ret; 71 } 72 73 int i915_gem_stolen_insert_node(struct drm_i915_private *dev_priv, 74 struct drm_mm_node *node, u64 size, 75 unsigned alignment) 76 { 77 struct i915_ggtt *ggtt = &dev_priv->ggtt; 78 79 return i915_gem_stolen_insert_node_in_range(dev_priv, node, size, 80 alignment, 0, 81 ggtt->stolen_usable_size); 82 } 83 84 void i915_gem_stolen_remove_node(struct drm_i915_private *dev_priv, 85 struct drm_mm_node *node) 86 { 87 mutex_lock(&dev_priv->mm.stolen_lock); 88 drm_mm_remove_node(node); 89 mutex_unlock(&dev_priv->mm.stolen_lock); 90 } 91 92 static unsigned long i915_stolen_to_physical(struct drm_device *dev) 93 { 94 struct drm_i915_private *dev_priv = to_i915(dev); 95 struct i915_ggtt *ggtt = &dev_priv->ggtt; 96 u32 base; 97 98 /* Almost universally we can find the Graphics Base of Stolen Memory 99 * at register BSM (0x5c) in the igfx configuration space. On a few 100 * (desktop) machines this is also mirrored in the bridge device at 101 * different locations, or in the MCHBAR. 102 * 103 * On 865 we just check the TOUD register. 104 * 105 * On 830/845/85x the stolen memory base isn't available in any 106 * register. We need to calculate it as TOM-TSEG_SIZE-stolen_size. 107 * 108 */ 109 base = 0; 110 if (INTEL_INFO(dev)->gen >= 3) { 111 u32 bsm; 112 113 pci_read_config_dword(dev->pdev, BSM, &bsm); 114 115 base = bsm & BSM_MASK; 116 } else if (IS_I865G(dev)) { 117 u16 toud = 0; 118 119 /* 120 * FIXME is the graphics stolen memory region 121 * always at TOUD? Ie. is it always the last 122 * one to be allocated by the BIOS? 123 */ 124 pci_bus_read_config_word(dev->pdev->bus, PCI_DEVFN(0, 0), 125 I865_TOUD, &toud); 126 127 base = toud << 16; 128 } else if (IS_I85X(dev)) { 129 u32 tseg_size = 0; 130 u32 tom; 131 u8 tmp; 132 133 pci_bus_read_config_byte(dev->pdev->bus, PCI_DEVFN(0, 0), 134 I85X_ESMRAMC, &tmp); 135 136 if (tmp & TSEG_ENABLE) 137 tseg_size = MB(1); 138 139 pci_bus_read_config_byte(dev->pdev->bus, PCI_DEVFN(0, 1), 140 I85X_DRB3, &tmp); 141 tom = tmp * MB(32); 142 143 base = tom - tseg_size - ggtt->stolen_size; 144 } else if (IS_845G(dev)) { 145 u32 tseg_size = 0; 146 u32 tom; 147 u8 tmp; 148 149 pci_bus_read_config_byte(dev->pdev->bus, PCI_DEVFN(0, 0), 150 I845_ESMRAMC, &tmp); 151 152 if (tmp & TSEG_ENABLE) { 153 switch (tmp & I845_TSEG_SIZE_MASK) { 154 case I845_TSEG_SIZE_512K: 155 tseg_size = KB(512); 156 break; 157 case I845_TSEG_SIZE_1M: 158 tseg_size = MB(1); 159 break; 160 } 161 } 162 163 pci_bus_read_config_byte(dev->pdev->bus, PCI_DEVFN(0, 0), 164 I830_DRB3, &tmp); 165 tom = tmp * MB(32); 166 167 base = tom - tseg_size - ggtt->stolen_size; 168 } else if (IS_I830(dev)) { 169 u32 tseg_size = 0; 170 u32 tom; 171 u8 tmp; 172 173 pci_bus_read_config_byte(dev->pdev->bus, PCI_DEVFN(0, 0), 174 I830_ESMRAMC, &tmp); 175 176 if (tmp & TSEG_ENABLE) { 177 if (tmp & I830_TSEG_SIZE_1M) 178 tseg_size = MB(1); 179 else 180 tseg_size = KB(512); 181 } 182 183 pci_bus_read_config_byte(dev->pdev->bus, PCI_DEVFN(0, 0), 184 I830_DRB3, &tmp); 185 tom = tmp * MB(32); 186 187 base = tom - tseg_size - ggtt->stolen_size; 188 } 189 190 if (base == 0) 191 return 0; 192 193 /* make sure we don't clobber the GTT if it's within stolen memory */ 194 if (INTEL_INFO(dev)->gen <= 4 && !IS_G33(dev) && !IS_G4X(dev)) { 195 struct { 196 u32 start, end; 197 } stolen[2] = { 198 { .start = base, .end = base + ggtt->stolen_size, }, 199 { .start = base, .end = base + ggtt->stolen_size, }, 200 }; 201 u64 ggtt_start, ggtt_end; 202 203 ggtt_start = I915_READ(PGTBL_CTL); 204 if (IS_GEN4(dev)) 205 ggtt_start = (ggtt_start & PGTBL_ADDRESS_LO_MASK) | 206 (ggtt_start & PGTBL_ADDRESS_HI_MASK) << 28; 207 else 208 ggtt_start &= PGTBL_ADDRESS_LO_MASK; 209 ggtt_end = ggtt_start + ggtt_total_entries(ggtt) * 4; 210 211 if (ggtt_start >= stolen[0].start && ggtt_start < stolen[0].end) 212 stolen[0].end = ggtt_start; 213 if (ggtt_end > stolen[1].start && ggtt_end <= stolen[1].end) 214 stolen[1].start = ggtt_end; 215 216 /* pick the larger of the two chunks */ 217 if (stolen[0].end - stolen[0].start > 218 stolen[1].end - stolen[1].start) { 219 base = stolen[0].start; 220 ggtt->stolen_size = stolen[0].end - stolen[0].start; 221 } else { 222 base = stolen[1].start; 223 ggtt->stolen_size = stolen[1].end - stolen[1].start; 224 } 225 226 if (stolen[0].start != stolen[1].start || 227 stolen[0].end != stolen[1].end) { 228 DRM_DEBUG_KMS("GTT within stolen memory at 0x%llx-0x%llx\n", 229 (unsigned long long)ggtt_start, 230 (unsigned long long)ggtt_end - 1); 231 DRM_DEBUG_KMS("Stolen memory adjusted to 0x%x-0x%x\n", 232 base, base + (u32)ggtt->stolen_size - 1); 233 } 234 } 235 236 237 /* Verify that nothing else uses this physical address. Stolen 238 * memory should be reserved by the BIOS and hidden from the 239 * kernel. So if the region is already marked as busy, something 240 * is seriously wrong. 241 */ 242 #if 0 243 r = devm_request_mem_region(dev->dev, base, ggtt->stolen_size, 244 "Graphics Stolen Memory"); 245 if (r == NULL) { 246 /* 247 * One more attempt but this time requesting region from 248 * base + 1, as we have seen that this resolves the region 249 * conflict with the PCI Bus. 250 * This is a BIOS w/a: Some BIOS wrap stolen in the root 251 * PCI bus, but have an off-by-one error. Hence retry the 252 * reservation starting from 1 instead of 0. 253 */ 254 r = devm_request_mem_region(dev->dev, base + 1, 255 ggtt->stolen_size - 1, 256 "Graphics Stolen Memory"); 257 /* 258 * GEN3 firmware likes to smash pci bridges into the stolen 259 * range. Apparently this works. 260 */ 261 if (r == NULL && !IS_GEN3(dev)) { 262 DRM_ERROR("conflict detected with stolen region: [0x%08x - 0x%08x]\n", 263 base, base + (uint32_t)ggtt->stolen_size); 264 base = 0; 265 } 266 } 267 #endif 268 269 return base; 270 } 271 272 void i915_gem_cleanup_stolen(struct drm_device *dev) 273 { 274 struct drm_i915_private *dev_priv = dev->dev_private; 275 276 if (!drm_mm_initialized(&dev_priv->mm.stolen)) 277 return; 278 279 drm_mm_takedown(&dev_priv->mm.stolen); 280 } 281 282 static void g4x_get_stolen_reserved(struct drm_i915_private *dev_priv, 283 unsigned long *base, unsigned long *size) 284 { 285 struct i915_ggtt *ggtt = &dev_priv->ggtt; 286 uint32_t reg_val = I915_READ(IS_GM45(dev_priv) ? 287 CTG_STOLEN_RESERVED : 288 ELK_STOLEN_RESERVED); 289 unsigned long stolen_top = dev_priv->mm.stolen_base + 290 ggtt->stolen_size; 291 292 *base = (reg_val & G4X_STOLEN_RESERVED_ADDR2_MASK) << 16; 293 294 WARN_ON((reg_val & G4X_STOLEN_RESERVED_ADDR1_MASK) < *base); 295 296 /* On these platforms, the register doesn't have a size field, so the 297 * size is the distance between the base and the top of the stolen 298 * memory. We also have the genuine case where base is zero and there's 299 * nothing reserved. */ 300 if (*base == 0) 301 *size = 0; 302 else 303 *size = stolen_top - *base; 304 } 305 306 static void gen6_get_stolen_reserved(struct drm_i915_private *dev_priv, 307 unsigned long *base, unsigned long *size) 308 { 309 uint32_t reg_val = I915_READ(GEN6_STOLEN_RESERVED); 310 311 *base = reg_val & GEN6_STOLEN_RESERVED_ADDR_MASK; 312 313 switch (reg_val & GEN6_STOLEN_RESERVED_SIZE_MASK) { 314 case GEN6_STOLEN_RESERVED_1M: 315 *size = 1024 * 1024; 316 break; 317 case GEN6_STOLEN_RESERVED_512K: 318 *size = 512 * 1024; 319 break; 320 case GEN6_STOLEN_RESERVED_256K: 321 *size = 256 * 1024; 322 break; 323 case GEN6_STOLEN_RESERVED_128K: 324 *size = 128 * 1024; 325 break; 326 default: 327 *size = 1024 * 1024; 328 MISSING_CASE(reg_val & GEN6_STOLEN_RESERVED_SIZE_MASK); 329 } 330 } 331 332 static void gen7_get_stolen_reserved(struct drm_i915_private *dev_priv, 333 unsigned long *base, unsigned long *size) 334 { 335 uint32_t reg_val = I915_READ(GEN6_STOLEN_RESERVED); 336 337 *base = reg_val & GEN7_STOLEN_RESERVED_ADDR_MASK; 338 339 switch (reg_val & GEN7_STOLEN_RESERVED_SIZE_MASK) { 340 case GEN7_STOLEN_RESERVED_1M: 341 *size = 1024 * 1024; 342 break; 343 case GEN7_STOLEN_RESERVED_256K: 344 *size = 256 * 1024; 345 break; 346 default: 347 *size = 1024 * 1024; 348 MISSING_CASE(reg_val & GEN7_STOLEN_RESERVED_SIZE_MASK); 349 } 350 } 351 352 static void gen8_get_stolen_reserved(struct drm_i915_private *dev_priv, 353 unsigned long *base, unsigned long *size) 354 { 355 uint32_t reg_val = I915_READ(GEN6_STOLEN_RESERVED); 356 357 *base = reg_val & GEN6_STOLEN_RESERVED_ADDR_MASK; 358 359 switch (reg_val & GEN8_STOLEN_RESERVED_SIZE_MASK) { 360 case GEN8_STOLEN_RESERVED_1M: 361 *size = 1024 * 1024; 362 break; 363 case GEN8_STOLEN_RESERVED_2M: 364 *size = 2 * 1024 * 1024; 365 break; 366 case GEN8_STOLEN_RESERVED_4M: 367 *size = 4 * 1024 * 1024; 368 break; 369 case GEN8_STOLEN_RESERVED_8M: 370 *size = 8 * 1024 * 1024; 371 break; 372 default: 373 *size = 8 * 1024 * 1024; 374 MISSING_CASE(reg_val & GEN8_STOLEN_RESERVED_SIZE_MASK); 375 } 376 } 377 378 static void bdw_get_stolen_reserved(struct drm_i915_private *dev_priv, 379 unsigned long *base, unsigned long *size) 380 { 381 struct i915_ggtt *ggtt = &dev_priv->ggtt; 382 uint32_t reg_val = I915_READ(GEN6_STOLEN_RESERVED); 383 unsigned long stolen_top; 384 385 stolen_top = dev_priv->mm.stolen_base + ggtt->stolen_size; 386 387 *base = reg_val & GEN6_STOLEN_RESERVED_ADDR_MASK; 388 389 /* On these platforms, the register doesn't have a size field, so the 390 * size is the distance between the base and the top of the stolen 391 * memory. We also have the genuine case where base is zero and there's 392 * nothing reserved. */ 393 if (*base == 0) 394 *size = 0; 395 else 396 *size = stolen_top - *base; 397 } 398 399 int i915_gem_init_stolen(struct drm_device *dev) 400 { 401 struct drm_i915_private *dev_priv = to_i915(dev); 402 struct i915_ggtt *ggtt = &dev_priv->ggtt; 403 unsigned long reserved_total, reserved_base = 0, reserved_size; 404 unsigned long stolen_top; 405 406 lockinit(&dev_priv->mm.stolen_lock, "i915msl", 0, LK_CANRECURSE); 407 #ifdef __DragonFly__ 408 /* Stolen memory support is still incomplete */ 409 return 0; 410 #endif 411 412 #ifdef CONFIG_INTEL_IOMMU 413 if (intel_iommu_gfx_mapped && INTEL_INFO(dev)->gen < 8) { 414 DRM_INFO("DMAR active, disabling use of stolen memory\n"); 415 return 0; 416 } 417 #endif 418 419 if (ggtt->stolen_size == 0) 420 return 0; 421 422 dev_priv->mm.stolen_base = i915_stolen_to_physical(dev); 423 if (dev_priv->mm.stolen_base == 0) 424 return 0; 425 426 stolen_top = dev_priv->mm.stolen_base + ggtt->stolen_size; 427 428 switch (INTEL_INFO(dev_priv)->gen) { 429 case 2: 430 case 3: 431 break; 432 case 4: 433 if (IS_G4X(dev)) 434 g4x_get_stolen_reserved(dev_priv, &reserved_base, 435 &reserved_size); 436 break; 437 case 5: 438 /* Assume the gen6 maximum for the older platforms. */ 439 reserved_size = 1024 * 1024; 440 reserved_base = stolen_top - reserved_size; 441 break; 442 case 6: 443 gen6_get_stolen_reserved(dev_priv, &reserved_base, 444 &reserved_size); 445 break; 446 case 7: 447 gen7_get_stolen_reserved(dev_priv, &reserved_base, 448 &reserved_size); 449 break; 450 default: 451 if (IS_BROADWELL(dev_priv) || 452 IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev)) 453 bdw_get_stolen_reserved(dev_priv, &reserved_base, 454 &reserved_size); 455 else 456 gen8_get_stolen_reserved(dev_priv, &reserved_base, 457 &reserved_size); 458 break; 459 } 460 461 /* It is possible for the reserved base to be zero, but the register 462 * field for size doesn't have a zero option. */ 463 if (reserved_base == 0) { 464 reserved_size = 0; 465 reserved_base = stolen_top; 466 } 467 468 if (reserved_base < dev_priv->mm.stolen_base || 469 reserved_base + reserved_size > stolen_top) { 470 DRM_DEBUG_KMS("Stolen reserved area [0x%08lx - 0x%08lx] outside stolen memory [0x%08lx - 0x%08lx]\n", 471 reserved_base, reserved_base + reserved_size, 472 dev_priv->mm.stolen_base, stolen_top); 473 return 0; 474 } 475 476 ggtt->stolen_reserved_base = reserved_base; 477 ggtt->stolen_reserved_size = reserved_size; 478 479 /* It is possible for the reserved area to end before the end of stolen 480 * memory, so just consider the start. */ 481 reserved_total = stolen_top - reserved_base; 482 483 DRM_DEBUG_KMS("Memory reserved for graphics device: %zuK, usable: %luK\n", 484 ggtt->stolen_size >> 10, 485 (ggtt->stolen_size - reserved_total) >> 10); 486 487 ggtt->stolen_usable_size = ggtt->stolen_size - reserved_total; 488 489 /* 490 * Basic memrange allocator for stolen space. 491 * 492 * TODO: Notice that some platforms require us to not use the first page 493 * of the stolen memory but their BIOSes may still put the framebuffer 494 * on the first page. So we don't reserve this page for now because of 495 * that. Our current solution is to just prevent new nodes from being 496 * inserted on the first page - see the check we have at 497 * i915_gem_stolen_insert_node_in_range(). We may want to fix the fbcon 498 * problem later. 499 */ 500 drm_mm_init(&dev_priv->mm.stolen, 0, ggtt->stolen_usable_size); 501 502 return 0; 503 } 504 505 static struct sg_table * 506 i915_pages_create_for_stolen(struct drm_device *dev, 507 u32 offset, u32 size) 508 { 509 struct drm_i915_private *dev_priv = to_i915(dev); 510 struct i915_ggtt *ggtt = &dev_priv->ggtt; 511 struct sg_table *st; 512 struct scatterlist *sg; 513 514 DRM_DEBUG_DRIVER("offset=0x%x, size=%d\n", offset, size); 515 BUG_ON(offset > ggtt->stolen_size - size); 516 517 /* We hide that we have no struct page backing our stolen object 518 * by wrapping the contiguous physical allocation with a fake 519 * dma mapping in a single scatterlist. 520 */ 521 522 st = kmalloc(sizeof(*st), M_DRM, M_WAITOK); 523 if (st == NULL) 524 return NULL; 525 526 if (sg_alloc_table(st, 1, GFP_KERNEL)) { 527 kfree(st); 528 return NULL; 529 } 530 531 sg = st->sgl; 532 sg->offset = 0; 533 sg->length = size; 534 535 sg_dma_address(sg) = (dma_addr_t)dev_priv->mm.stolen_base + offset; 536 sg_dma_len(sg) = size; 537 538 return st; 539 } 540 541 static int i915_gem_object_get_pages_stolen(struct drm_i915_gem_object *obj) 542 { 543 BUG(); 544 return -EINVAL; 545 } 546 547 static void i915_gem_object_put_pages_stolen(struct drm_i915_gem_object *obj) 548 { 549 /* Should only be called during free */ 550 sg_free_table(obj->pages); 551 kfree(obj->pages); 552 } 553 554 555 static void 556 i915_gem_object_release_stolen(struct drm_i915_gem_object *obj) 557 { 558 struct drm_i915_private *dev_priv = obj->base.dev->dev_private; 559 560 if (obj->stolen) { 561 i915_gem_stolen_remove_node(dev_priv, obj->stolen); 562 kfree(obj->stolen); 563 obj->stolen = NULL; 564 } 565 } 566 static const struct drm_i915_gem_object_ops i915_gem_object_stolen_ops = { 567 .get_pages = i915_gem_object_get_pages_stolen, 568 .put_pages = i915_gem_object_put_pages_stolen, 569 .release = i915_gem_object_release_stolen, 570 }; 571 572 static struct drm_i915_gem_object * 573 _i915_gem_object_create_stolen(struct drm_device *dev, 574 struct drm_mm_node *stolen) 575 { 576 struct drm_i915_gem_object *obj; 577 578 obj = i915_gem_object_alloc(dev); 579 if (obj == NULL) 580 return NULL; 581 582 drm_gem_private_object_init(dev, &obj->base, stolen->size); 583 i915_gem_object_init(obj, &i915_gem_object_stolen_ops); 584 585 obj->pages = i915_pages_create_for_stolen(dev, 586 stolen->start, stolen->size); 587 if (obj->pages == NULL) 588 goto cleanup; 589 590 obj->get_page.sg = obj->pages->sgl; 591 obj->get_page.last = 0; 592 593 i915_gem_object_pin_pages(obj); 594 obj->stolen = stolen; 595 596 obj->base.read_domains = I915_GEM_DOMAIN_CPU | I915_GEM_DOMAIN_GTT; 597 obj->cache_level = HAS_LLC(dev) ? I915_CACHE_LLC : I915_CACHE_NONE; 598 599 return obj; 600 601 cleanup: 602 i915_gem_object_free(obj); 603 return NULL; 604 } 605 606 struct drm_i915_gem_object * 607 i915_gem_object_create_stolen(struct drm_device *dev, u32 size) 608 { 609 struct drm_i915_private *dev_priv = dev->dev_private; 610 struct drm_i915_gem_object *obj; 611 struct drm_mm_node *stolen; 612 int ret; 613 614 if (!drm_mm_initialized(&dev_priv->mm.stolen)) 615 return NULL; 616 617 DRM_DEBUG_KMS("creating stolen object: size=%x\n", size); 618 if (size == 0) 619 return NULL; 620 621 stolen = kzalloc(sizeof(*stolen), GFP_KERNEL); 622 if (!stolen) 623 return NULL; 624 625 ret = i915_gem_stolen_insert_node(dev_priv, stolen, size, 4096); 626 if (ret) { 627 kfree(stolen); 628 return NULL; 629 } 630 631 obj = _i915_gem_object_create_stolen(dev, stolen); 632 if (obj) 633 return obj; 634 635 i915_gem_stolen_remove_node(dev_priv, stolen); 636 kfree(stolen); 637 return NULL; 638 } 639 640 struct drm_i915_gem_object * 641 i915_gem_object_create_stolen_for_preallocated(struct drm_device *dev, 642 u32 stolen_offset, 643 u32 gtt_offset, 644 u32 size) 645 { 646 struct drm_i915_private *dev_priv = to_i915(dev); 647 struct i915_ggtt *ggtt = &dev_priv->ggtt; 648 struct drm_i915_gem_object *obj; 649 struct drm_mm_node *stolen; 650 struct i915_vma *vma; 651 int ret; 652 653 if (!drm_mm_initialized(&dev_priv->mm.stolen)) 654 return NULL; 655 656 lockdep_assert_held(&dev->struct_mutex); 657 658 DRM_DEBUG_KMS("creating preallocated stolen object: stolen_offset=%x, gtt_offset=%x, size=%x\n", 659 stolen_offset, gtt_offset, size); 660 661 /* KISS and expect everything to be page-aligned */ 662 if (WARN_ON(size == 0) || WARN_ON(size & 4095) || 663 WARN_ON(stolen_offset & 4095)) 664 return NULL; 665 666 stolen = kzalloc(sizeof(*stolen), GFP_KERNEL); 667 if (!stolen) 668 return NULL; 669 670 stolen->start = stolen_offset; 671 stolen->size = size; 672 mutex_lock(&dev_priv->mm.stolen_lock); 673 ret = drm_mm_reserve_node(&dev_priv->mm.stolen, stolen); 674 mutex_unlock(&dev_priv->mm.stolen_lock); 675 if (ret) { 676 DRM_DEBUG_KMS("failed to allocate stolen space\n"); 677 kfree(stolen); 678 return NULL; 679 } 680 681 obj = _i915_gem_object_create_stolen(dev, stolen); 682 if (obj == NULL) { 683 DRM_DEBUG_KMS("failed to allocate stolen object\n"); 684 i915_gem_stolen_remove_node(dev_priv, stolen); 685 kfree(stolen); 686 return NULL; 687 } 688 689 /* Some objects just need physical mem from stolen space */ 690 if (gtt_offset == I915_GTT_OFFSET_NONE) 691 return obj; 692 693 vma = i915_gem_obj_lookup_or_create_vma(obj, &ggtt->base); 694 if (IS_ERR(vma)) { 695 ret = PTR_ERR(vma); 696 goto err; 697 } 698 699 /* To simplify the initialisation sequence between KMS and GTT, 700 * we allow construction of the stolen object prior to 701 * setting up the GTT space. The actual reservation will occur 702 * later. 703 */ 704 vma->node.start = gtt_offset; 705 vma->node.size = size; 706 if (drm_mm_initialized(&ggtt->base.mm)) { 707 ret = drm_mm_reserve_node(&ggtt->base.mm, &vma->node); 708 if (ret) { 709 DRM_DEBUG_KMS("failed to allocate stolen GTT space\n"); 710 goto err; 711 } 712 713 vma->bound |= GLOBAL_BIND; 714 __i915_vma_set_map_and_fenceable(vma); 715 list_add_tail(&vma->vm_link, &ggtt->base.inactive_list); 716 } 717 718 list_add_tail(&obj->global_list, &dev_priv->mm.bound_list); 719 i915_gem_object_pin_pages(obj); 720 721 return obj; 722 723 err: 724 drm_gem_object_unreference(&obj->base); 725 return NULL; 726 } 727