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