1 /* 2 * Copyright 2012 Red Hat Inc. 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 shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Authors: Ben Skeggs 23 */ 24 25 #ifdef HAVE_CONFIG_H 26 #include <config.h> 27 #endif 28 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <stdint.h> 32 #include <stdbool.h> 33 #include <string.h> 34 #include <assert.h> 35 #include <errno.h> 36 37 #include <xf86drm.h> 38 #include <xf86atomic.h> 39 #include "libdrm_lists.h" 40 #include "nouveau_drm.h" 41 42 #include "nouveau.h" 43 #include "private.h" 44 45 struct nouveau_pushbuf_krec { 46 struct nouveau_pushbuf_krec *next; 47 struct drm_nouveau_gem_pushbuf_bo buffer[NOUVEAU_GEM_MAX_BUFFERS]; 48 struct drm_nouveau_gem_pushbuf_reloc reloc[NOUVEAU_GEM_MAX_RELOCS]; 49 struct drm_nouveau_gem_pushbuf_push push[NOUVEAU_GEM_MAX_PUSH]; 50 int nr_buffer; 51 int nr_reloc; 52 int nr_push; 53 uint64_t vram_used; 54 uint64_t gart_used; 55 }; 56 57 struct nouveau_pushbuf_priv { 58 struct nouveau_pushbuf base; 59 struct nouveau_pushbuf_krec *list; 60 struct nouveau_pushbuf_krec *krec; 61 struct nouveau_list bctx_list; 62 struct nouveau_bo *bo; 63 uint32_t type; 64 uint32_t suffix0; 65 uint32_t suffix1; 66 uint32_t *ptr; 67 uint32_t *bgn; 68 int bo_next; 69 int bo_nr; 70 struct nouveau_bo *bos[]; 71 }; 72 73 static inline struct nouveau_pushbuf_priv * 74 nouveau_pushbuf(struct nouveau_pushbuf *push) 75 { 76 return (struct nouveau_pushbuf_priv *)push; 77 } 78 79 static int pushbuf_validate(struct nouveau_pushbuf *, bool); 80 static int pushbuf_flush(struct nouveau_pushbuf *); 81 82 static bool 83 pushbuf_kref_fits(struct nouveau_pushbuf *push, struct nouveau_bo *bo, 84 uint32_t *domains) 85 { 86 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 87 struct nouveau_pushbuf_krec *krec = nvpb->krec; 88 struct nouveau_device *dev = push->client->device; 89 struct nouveau_bo *kbo; 90 struct drm_nouveau_gem_pushbuf_bo *kref; 91 int i; 92 93 /* VRAM is the only valid domain. GART and VRAM|GART buffers 94 * are all accounted to GART, so if this doesn't fit in VRAM 95 * straight up, a flush is needed. 96 */ 97 if (*domains == NOUVEAU_GEM_DOMAIN_VRAM) { 98 if (krec->vram_used + bo->size > dev->vram_limit) 99 return false; 100 krec->vram_used += bo->size; 101 return true; 102 } 103 104 /* GART or VRAM|GART buffer. Account both of these buffer types 105 * to GART only for the moment, which simplifies things. If the 106 * buffer can fit already, we're done here. 107 */ 108 if (krec->gart_used + bo->size <= dev->gart_limit) { 109 krec->gart_used += bo->size; 110 return true; 111 } 112 113 /* Ran out of GART space, if it's a VRAM|GART buffer and it'll 114 * fit into available VRAM, turn it into a VRAM buffer 115 */ 116 if ((*domains & NOUVEAU_GEM_DOMAIN_VRAM) && 117 krec->vram_used + bo->size <= dev->vram_limit) { 118 *domains &= NOUVEAU_GEM_DOMAIN_VRAM; 119 krec->vram_used += bo->size; 120 return true; 121 } 122 123 /* Still couldn't fit the buffer in anywhere, so as a last resort; 124 * scan the buffer list for VRAM|GART buffers and turn them into 125 * VRAM buffers until we have enough space in GART for this one 126 */ 127 kref = krec->buffer; 128 for (i = 0; i < krec->nr_buffer; i++, kref++) { 129 if (!(kref->valid_domains & NOUVEAU_GEM_DOMAIN_GART)) 130 continue; 131 132 kbo = (void *)(unsigned long)kref->user_priv; 133 if (!(kref->valid_domains & NOUVEAU_GEM_DOMAIN_VRAM) || 134 krec->vram_used + kbo->size > dev->vram_limit) 135 continue; 136 137 kref->valid_domains &= NOUVEAU_GEM_DOMAIN_VRAM; 138 krec->gart_used -= kbo->size; 139 krec->vram_used += kbo->size; 140 if (krec->gart_used + bo->size <= dev->gart_limit) { 141 krec->gart_used += bo->size; 142 return true; 143 } 144 } 145 146 /* Couldn't resolve a placement, need to force a flush */ 147 return false; 148 } 149 150 static struct drm_nouveau_gem_pushbuf_bo * 151 pushbuf_kref(struct nouveau_pushbuf *push, struct nouveau_bo *bo, 152 uint32_t flags) 153 { 154 struct nouveau_device *dev = push->client->device; 155 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 156 struct nouveau_pushbuf_krec *krec = nvpb->krec; 157 struct nouveau_pushbuf *fpush; 158 struct drm_nouveau_gem_pushbuf_bo *kref; 159 uint32_t domains, domains_wr, domains_rd; 160 161 domains = 0; 162 if (flags & NOUVEAU_BO_VRAM) 163 domains |= NOUVEAU_GEM_DOMAIN_VRAM; 164 if (flags & NOUVEAU_BO_GART) 165 domains |= NOUVEAU_GEM_DOMAIN_GART; 166 domains_wr = domains * !!(flags & NOUVEAU_BO_WR); 167 domains_rd = domains * !!(flags & NOUVEAU_BO_RD); 168 169 /* if buffer is referenced on another pushbuf that is owned by the 170 * same client, we need to flush the other pushbuf first to ensure 171 * the correct ordering of commands 172 */ 173 fpush = cli_push_get(push->client, bo); 174 if (fpush && fpush != push) 175 pushbuf_flush(fpush); 176 177 kref = cli_kref_get(push->client, bo); 178 if (kref) { 179 /* possible conflict in memory types - flush and retry */ 180 if (!(kref->valid_domains & domains)) 181 return NULL; 182 183 /* VRAM|GART buffer turning into a VRAM buffer. Make sure 184 * it'll fit in VRAM and force a flush if not. 185 */ 186 if ((kref->valid_domains & NOUVEAU_GEM_DOMAIN_GART) && 187 ( domains == NOUVEAU_GEM_DOMAIN_VRAM)) { 188 if (krec->vram_used + bo->size > dev->vram_limit) 189 return NULL; 190 krec->vram_used += bo->size; 191 krec->gart_used -= bo->size; 192 } 193 194 kref->valid_domains &= domains; 195 kref->write_domains |= domains_wr; 196 kref->read_domains |= domains_rd; 197 } else { 198 if (krec->nr_buffer == NOUVEAU_GEM_MAX_BUFFERS || 199 !pushbuf_kref_fits(push, bo, &domains)) 200 return NULL; 201 202 kref = &krec->buffer[krec->nr_buffer++]; 203 kref->user_priv = (unsigned long)bo; 204 kref->handle = bo->handle; 205 kref->valid_domains = domains; 206 kref->write_domains = domains_wr; 207 kref->read_domains = domains_rd; 208 kref->presumed.valid = 1; 209 kref->presumed.offset = bo->offset; 210 if (bo->flags & NOUVEAU_BO_VRAM) 211 kref->presumed.domain = NOUVEAU_GEM_DOMAIN_VRAM; 212 else 213 kref->presumed.domain = NOUVEAU_GEM_DOMAIN_GART; 214 215 cli_kref_set(push->client, bo, kref, push); 216 atomic_inc(&nouveau_bo(bo)->refcnt); 217 } 218 219 return kref; 220 } 221 222 static uint32_t 223 pushbuf_krel(struct nouveau_pushbuf *push, struct nouveau_bo *bo, 224 uint32_t data, uint32_t flags, uint32_t vor, uint32_t tor) 225 { 226 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 227 struct nouveau_pushbuf_krec *krec = nvpb->krec; 228 struct drm_nouveau_gem_pushbuf_reloc *krel; 229 struct drm_nouveau_gem_pushbuf_bo *pkref; 230 struct drm_nouveau_gem_pushbuf_bo *bkref; 231 uint32_t reloc = data; 232 233 pkref = cli_kref_get(push->client, nvpb->bo); 234 bkref = cli_kref_get(push->client, bo); 235 krel = &krec->reloc[krec->nr_reloc++]; 236 237 assert(pkref); 238 assert(bkref); 239 krel->reloc_bo_index = pkref - krec->buffer; 240 krel->reloc_bo_offset = (push->cur - nvpb->ptr) * 4; 241 krel->bo_index = bkref - krec->buffer; 242 krel->flags = 0; 243 krel->data = data; 244 krel->vor = vor; 245 krel->tor = tor; 246 247 if (flags & NOUVEAU_BO_LOW) { 248 reloc = (bkref->presumed.offset + data); 249 krel->flags |= NOUVEAU_GEM_RELOC_LOW; 250 } else 251 if (flags & NOUVEAU_BO_HIGH) { 252 reloc = (bkref->presumed.offset + data) >> 32; 253 krel->flags |= NOUVEAU_GEM_RELOC_HIGH; 254 } 255 if (flags & NOUVEAU_BO_OR) { 256 if (bkref->presumed.domain & NOUVEAU_GEM_DOMAIN_VRAM) 257 reloc |= vor; 258 else 259 reloc |= tor; 260 krel->flags |= NOUVEAU_GEM_RELOC_OR; 261 } 262 263 return reloc; 264 } 265 266 static void 267 pushbuf_dump(struct nouveau_pushbuf_krec *krec, int krec_id, int chid) 268 { 269 struct drm_nouveau_gem_pushbuf_reloc *krel; 270 struct drm_nouveau_gem_pushbuf_push *kpsh; 271 struct drm_nouveau_gem_pushbuf_bo *kref; 272 struct nouveau_bo *bo; 273 uint32_t *bgn, *end; 274 int i; 275 276 err("ch%d: krec %d pushes %d bufs %d relocs %d\n", chid, 277 krec_id, krec->nr_push, krec->nr_buffer, krec->nr_reloc); 278 279 kref = krec->buffer; 280 for (i = 0; i < krec->nr_buffer; i++, kref++) { 281 err("ch%d: buf %08x %08x %08x %08x %08x\n", chid, i, 282 kref->handle, kref->valid_domains, 283 kref->read_domains, kref->write_domains); 284 } 285 286 krel = krec->reloc; 287 for (i = 0; i < krec->nr_reloc; i++, krel++) { 288 err("ch%d: rel %08x %08x %08x %08x %08x %08x %08x\n", 289 chid, krel->reloc_bo_index, krel->reloc_bo_offset, 290 krel->bo_index, krel->flags, krel->data, 291 krel->vor, krel->tor); 292 } 293 294 kpsh = krec->push; 295 for (i = 0; i < krec->nr_push; i++, kpsh++) { 296 kref = krec->buffer + kpsh->bo_index; 297 bo = (void *)(unsigned long)kref->user_priv; 298 bgn = (uint32_t *)((char *)bo->map + kpsh->offset); 299 end = bgn + (kpsh->length /4); 300 301 err("ch%d: psh %08x %010llx %010llx\n", chid, kpsh->bo_index, 302 (unsigned long long)kpsh->offset, 303 (unsigned long long)(kpsh->offset + kpsh->length)); 304 while (bgn < end) 305 err("\t0x%08x\n", *bgn++); 306 } 307 } 308 309 static int 310 pushbuf_submit(struct nouveau_pushbuf *push, struct nouveau_object *chan) 311 { 312 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 313 struct nouveau_pushbuf_krec *krec = nvpb->list; 314 struct nouveau_device *dev = push->client->device; 315 struct nouveau_drm *drm = nouveau_drm(&dev->object); 316 struct drm_nouveau_gem_pushbuf_bo_presumed *info; 317 struct drm_nouveau_gem_pushbuf_bo *kref; 318 struct drm_nouveau_gem_pushbuf req; 319 struct nouveau_fifo *fifo = chan->data; 320 struct nouveau_bo *bo; 321 int krec_id = 0; 322 int ret = 0, i; 323 324 if (chan->oclass != NOUVEAU_FIFO_CHANNEL_CLASS) 325 return -EINVAL; 326 327 if (push->kick_notify) 328 push->kick_notify(push); 329 330 nouveau_pushbuf_data(push, NULL, 0, 0); 331 332 while (krec && krec->nr_push) { 333 req.channel = fifo->channel; 334 req.nr_buffers = krec->nr_buffer; 335 req.buffers = (uint64_t)(unsigned long)krec->buffer; 336 req.nr_relocs = krec->nr_reloc; 337 req.nr_push = krec->nr_push; 338 req.relocs = (uint64_t)(unsigned long)krec->reloc; 339 req.push = (uint64_t)(unsigned long)krec->push; 340 req.suffix0 = nvpb->suffix0; 341 req.suffix1 = nvpb->suffix1; 342 req.vram_available = 0; /* for valgrind */ 343 req.gart_available = 0; 344 345 if (dbg_on(0)) 346 pushbuf_dump(krec, krec_id++, fifo->channel); 347 348 #ifndef SIMULATE 349 ret = drmCommandWriteRead(drm->fd, DRM_NOUVEAU_GEM_PUSHBUF, 350 &req, sizeof(req)); 351 nvpb->suffix0 = req.suffix0; 352 nvpb->suffix1 = req.suffix1; 353 dev->vram_limit = (req.vram_available * 354 nouveau_device(dev)->vram_limit_percent) / 100; 355 dev->gart_limit = (req.gart_available * 356 nouveau_device(dev)->gart_limit_percent) / 100; 357 #else 358 if (dbg_on(31)) 359 ret = -EINVAL; 360 #endif 361 362 if (ret) { 363 err("kernel rejected pushbuf: %s\n", strerror(-ret)); 364 pushbuf_dump(krec, krec_id++, fifo->channel); 365 break; 366 } 367 368 kref = krec->buffer; 369 for (i = 0; i < krec->nr_buffer; i++, kref++) { 370 bo = (void *)(unsigned long)kref->user_priv; 371 372 info = &kref->presumed; 373 if (!info->valid) { 374 bo->flags &= ~NOUVEAU_BO_APER; 375 if (info->domain == NOUVEAU_GEM_DOMAIN_VRAM) 376 bo->flags |= NOUVEAU_BO_VRAM; 377 else 378 bo->flags |= NOUVEAU_BO_GART; 379 bo->offset = info->offset; 380 } 381 382 if (kref->write_domains) 383 nouveau_bo(bo)->access |= NOUVEAU_BO_WR; 384 if (kref->read_domains) 385 nouveau_bo(bo)->access |= NOUVEAU_BO_RD; 386 } 387 388 krec = krec->next; 389 } 390 391 return ret; 392 } 393 394 static int 395 pushbuf_flush(struct nouveau_pushbuf *push) 396 { 397 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 398 struct nouveau_pushbuf_krec *krec = nvpb->krec; 399 struct drm_nouveau_gem_pushbuf_bo *kref; 400 struct nouveau_bufctx *bctx, *btmp; 401 struct nouveau_bo *bo; 402 int ret = 0, i; 403 404 if (push->channel) { 405 ret = pushbuf_submit(push, push->channel); 406 } else { 407 nouveau_pushbuf_data(push, NULL, 0, 0); 408 krec->next = malloc(sizeof(*krec)); 409 nvpb->krec = krec->next; 410 } 411 412 kref = krec->buffer; 413 for (i = 0; i < krec->nr_buffer; i++, kref++) { 414 bo = (void *)(unsigned long)kref->user_priv; 415 cli_kref_set(push->client, bo, NULL, NULL); 416 if (push->channel) 417 nouveau_bo_ref(NULL, &bo); 418 } 419 420 krec = nvpb->krec; 421 krec->vram_used = 0; 422 krec->gart_used = 0; 423 krec->nr_buffer = 0; 424 krec->nr_reloc = 0; 425 krec->nr_push = 0; 426 427 DRMLISTFOREACHENTRYSAFE(bctx, btmp, &nvpb->bctx_list, head) { 428 DRMLISTJOIN(&bctx->current, &bctx->pending); 429 DRMINITLISTHEAD(&bctx->current); 430 DRMLISTDELINIT(&bctx->head); 431 } 432 433 return ret; 434 } 435 436 static void 437 pushbuf_refn_fail(struct nouveau_pushbuf *push, int sref, int srel) 438 { 439 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 440 struct nouveau_pushbuf_krec *krec = nvpb->krec; 441 struct drm_nouveau_gem_pushbuf_bo *kref; 442 443 kref = krec->buffer + sref; 444 while (krec->nr_buffer-- > sref) { 445 struct nouveau_bo *bo = (void *)(unsigned long)kref->user_priv; 446 cli_kref_set(push->client, bo, NULL, NULL); 447 nouveau_bo_ref(NULL, &bo); 448 kref++; 449 } 450 krec->nr_buffer = sref; 451 krec->nr_reloc = srel; 452 } 453 454 static int 455 pushbuf_refn(struct nouveau_pushbuf *push, bool retry, 456 struct nouveau_pushbuf_refn *refs, int nr) 457 { 458 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 459 struct nouveau_pushbuf_krec *krec = nvpb->krec; 460 struct drm_nouveau_gem_pushbuf_bo *kref; 461 int sref = krec->nr_buffer; 462 int ret = 0, i; 463 464 for (i = 0; i < nr; i++) { 465 kref = pushbuf_kref(push, refs[i].bo, refs[i].flags); 466 if (!kref) { 467 ret = -ENOSPC; 468 break; 469 } 470 } 471 472 if (ret) { 473 pushbuf_refn_fail(push, sref, krec->nr_reloc); 474 if (retry) { 475 pushbuf_flush(push); 476 nouveau_pushbuf_space(push, 0, 0, 0); 477 return pushbuf_refn(push, false, refs, nr); 478 } 479 } 480 481 return ret; 482 } 483 484 static int 485 pushbuf_validate(struct nouveau_pushbuf *push, bool retry) 486 { 487 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 488 struct nouveau_pushbuf_krec *krec = nvpb->krec; 489 struct drm_nouveau_gem_pushbuf_bo *kref; 490 struct nouveau_bufctx *bctx = push->bufctx; 491 struct nouveau_bufref *bref; 492 int relocs = bctx ? bctx->relocs * 2: 0; 493 int sref, srel, ret; 494 495 ret = nouveau_pushbuf_space(push, relocs, relocs, 0); 496 if (ret || bctx == NULL) 497 return ret; 498 499 sref = krec->nr_buffer; 500 srel = krec->nr_reloc; 501 502 DRMLISTDEL(&bctx->head); 503 DRMLISTADD(&bctx->head, &nvpb->bctx_list); 504 505 DRMLISTFOREACHENTRY(bref, &bctx->pending, thead) { 506 kref = pushbuf_kref(push, bref->bo, bref->flags); 507 if (!kref) { 508 ret = -ENOSPC; 509 break; 510 } 511 512 if (bref->packet) { 513 pushbuf_krel(push, bref->bo, bref->packet, 0, 0, 0); 514 *push->cur++ = 0; 515 pushbuf_krel(push, bref->bo, bref->data, bref->flags, 516 bref->vor, bref->tor); 517 *push->cur++ = 0; 518 } 519 } 520 521 DRMLISTJOIN(&bctx->pending, &bctx->current); 522 DRMINITLISTHEAD(&bctx->pending); 523 524 if (ret) { 525 pushbuf_refn_fail(push, sref, srel); 526 if (retry) { 527 pushbuf_flush(push); 528 return pushbuf_validate(push, false); 529 } 530 } 531 532 return ret; 533 } 534 535 int 536 nouveau_pushbuf_new(struct nouveau_client *client, struct nouveau_object *chan, 537 int nr, uint32_t size, bool immediate, 538 struct nouveau_pushbuf **ppush) 539 { 540 struct nouveau_drm *drm = nouveau_drm(&client->device->object); 541 struct nouveau_fifo *fifo = chan->data; 542 struct nouveau_pushbuf_priv *nvpb; 543 struct nouveau_pushbuf *push; 544 struct drm_nouveau_gem_pushbuf req = {}; 545 int ret; 546 547 if (chan->oclass != NOUVEAU_FIFO_CHANNEL_CLASS) 548 return -EINVAL; 549 550 /* nop pushbuf call, to get the current "return to main" sequence 551 * we need to append to the pushbuf on early chipsets 552 */ 553 req.channel = fifo->channel; 554 req.nr_push = 0; 555 ret = drmCommandWriteRead(drm->fd, DRM_NOUVEAU_GEM_PUSHBUF, 556 &req, sizeof(req)); 557 if (ret) 558 return ret; 559 560 nvpb = calloc(1, sizeof(*nvpb) + nr * sizeof(*nvpb->bos)); 561 if (!nvpb) 562 return -ENOMEM; 563 564 #ifndef SIMULATE 565 nvpb->suffix0 = req.suffix0; 566 nvpb->suffix1 = req.suffix1; 567 #else 568 nvpb->suffix0 = 0xffffffff; 569 nvpb->suffix1 = 0xffffffff; 570 #endif 571 nvpb->krec = calloc(1, sizeof(*nvpb->krec)); 572 nvpb->list = nvpb->krec; 573 if (!nvpb->krec) { 574 free(nvpb); 575 return -ENOMEM; 576 } 577 578 push = &nvpb->base; 579 push->client = client; 580 push->channel = immediate ? chan : NULL; 581 push->flags = NOUVEAU_BO_RD; 582 if (fifo->pushbuf & NOUVEAU_GEM_DOMAIN_GART) { 583 push->flags |= NOUVEAU_BO_GART; 584 nvpb->type = NOUVEAU_BO_GART; 585 } else 586 if (fifo->pushbuf & NOUVEAU_GEM_DOMAIN_VRAM) { 587 push->flags |= NOUVEAU_BO_VRAM; 588 nvpb->type = NOUVEAU_BO_VRAM; 589 } 590 nvpb->type |= NOUVEAU_BO_MAP; 591 592 for (nvpb->bo_nr = 0; nvpb->bo_nr < nr; nvpb->bo_nr++) { 593 ret = nouveau_bo_new(client->device, nvpb->type, 0, size, 594 NULL, &nvpb->bos[nvpb->bo_nr]); 595 if (ret) { 596 nouveau_pushbuf_del(&push); 597 return ret; 598 } 599 } 600 601 DRMINITLISTHEAD(&nvpb->bctx_list); 602 *ppush = push; 603 return 0; 604 } 605 606 void 607 nouveau_pushbuf_del(struct nouveau_pushbuf **ppush) 608 { 609 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(*ppush); 610 if (nvpb) { 611 struct drm_nouveau_gem_pushbuf_bo *kref; 612 struct nouveau_pushbuf_krec *krec; 613 while ((krec = nvpb->list)) { 614 kref = krec->buffer; 615 while (krec->nr_buffer--) { 616 unsigned long priv = kref++->user_priv; 617 struct nouveau_bo *bo = (void *)priv; 618 cli_kref_set(nvpb->base.client, bo, NULL, NULL); 619 nouveau_bo_ref(NULL, &bo); 620 } 621 nvpb->list = krec->next; 622 free(krec); 623 } 624 while (nvpb->bo_nr--) 625 nouveau_bo_ref(NULL, &nvpb->bos[nvpb->bo_nr]); 626 nouveau_bo_ref(NULL, &nvpb->bo); 627 free(nvpb); 628 } 629 *ppush = NULL; 630 } 631 632 struct nouveau_bufctx * 633 nouveau_pushbuf_bufctx(struct nouveau_pushbuf *push, struct nouveau_bufctx *ctx) 634 { 635 struct nouveau_bufctx *prev = push->bufctx; 636 push->bufctx = ctx; 637 return prev; 638 } 639 640 int 641 nouveau_pushbuf_space(struct nouveau_pushbuf *push, 642 uint32_t dwords, uint32_t relocs, uint32_t pushes) 643 { 644 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 645 struct nouveau_pushbuf_krec *krec = nvpb->krec; 646 struct nouveau_client *client = push->client; 647 struct nouveau_bo *bo = NULL; 648 bool flushed = false; 649 int ret = 0; 650 651 /* switch to next buffer if insufficient space in the current one */ 652 if (push->cur + dwords >= push->end) { 653 if (nvpb->bo_next < nvpb->bo_nr) { 654 nouveau_bo_ref(nvpb->bos[nvpb->bo_next++], &bo); 655 if (nvpb->bo_next == nvpb->bo_nr && push->channel) 656 nvpb->bo_next = 0; 657 } else { 658 ret = nouveau_bo_new(client->device, nvpb->type, 0, 659 nvpb->bos[0]->size, NULL, &bo); 660 if (ret) 661 return ret; 662 } 663 } 664 665 /* make sure there's always enough space to queue up the pending 666 * data in the pushbuf proper 667 */ 668 pushes++; 669 670 /* need to flush if we've run out of space on an immediate pushbuf, 671 * if the new buffer won't fit, or if the kernel push/reloc limits 672 * have been hit 673 */ 674 if ((bo && ( push->channel || 675 !pushbuf_kref(push, bo, push->flags))) || 676 krec->nr_reloc + relocs >= NOUVEAU_GEM_MAX_RELOCS || 677 krec->nr_push + pushes >= NOUVEAU_GEM_MAX_PUSH) { 678 if (nvpb->bo && krec->nr_buffer) 679 pushbuf_flush(push); 680 flushed = true; 681 } 682 683 /* if necessary, switch to new buffer */ 684 if (bo) { 685 ret = nouveau_bo_map(bo, NOUVEAU_BO_WR, push->client); 686 if (ret) 687 return ret; 688 689 nouveau_pushbuf_data(push, NULL, 0, 0); 690 nouveau_bo_ref(bo, &nvpb->bo); 691 nouveau_bo_ref(NULL, &bo); 692 693 nvpb->bgn = nvpb->bo->map; 694 nvpb->ptr = nvpb->bgn; 695 push->cur = nvpb->bgn; 696 push->end = push->cur + (nvpb->bo->size / 4); 697 push->end -= 2 + push->rsvd_kick; /* space for suffix */ 698 } 699 700 pushbuf_kref(push, nvpb->bo, push->flags); 701 return flushed ? pushbuf_validate(push, false) : 0; 702 } 703 704 void 705 nouveau_pushbuf_data(struct nouveau_pushbuf *push, struct nouveau_bo *bo, 706 uint64_t offset, uint64_t length) 707 { 708 struct nouveau_pushbuf_priv *nvpb = nouveau_pushbuf(push); 709 struct nouveau_pushbuf_krec *krec = nvpb->krec; 710 struct drm_nouveau_gem_pushbuf_push *kpsh; 711 struct drm_nouveau_gem_pushbuf_bo *kref; 712 713 if (bo != nvpb->bo && nvpb->bgn != push->cur) { 714 if (nvpb->suffix0 || nvpb->suffix1) { 715 *push->cur++ = nvpb->suffix0; 716 *push->cur++ = nvpb->suffix1; 717 } 718 719 nouveau_pushbuf_data(push, nvpb->bo, 720 (nvpb->bgn - nvpb->ptr) * 4, 721 (push->cur - nvpb->bgn) * 4); 722 nvpb->bgn = push->cur; 723 } 724 725 if (bo) { 726 kref = cli_kref_get(push->client, bo); 727 assert(kref); 728 kpsh = &krec->push[krec->nr_push++]; 729 kpsh->bo_index = kref - krec->buffer; 730 kpsh->offset = offset; 731 kpsh->length = length; 732 } 733 } 734 735 int 736 nouveau_pushbuf_refn(struct nouveau_pushbuf *push, 737 struct nouveau_pushbuf_refn *refs, int nr) 738 { 739 return pushbuf_refn(push, true, refs, nr); 740 } 741 742 void 743 nouveau_pushbuf_reloc(struct nouveau_pushbuf *push, struct nouveau_bo *bo, 744 uint32_t data, uint32_t flags, uint32_t vor, uint32_t tor) 745 { 746 *push->cur = pushbuf_krel(push, bo, data, flags, vor, tor); 747 push->cur++; 748 } 749 750 int 751 nouveau_pushbuf_validate(struct nouveau_pushbuf *push) 752 { 753 return pushbuf_validate(push, true); 754 } 755 756 uint32_t 757 nouveau_pushbuf_refd(struct nouveau_pushbuf *push, struct nouveau_bo *bo) 758 { 759 struct drm_nouveau_gem_pushbuf_bo *kref; 760 uint32_t flags = 0; 761 762 if (cli_push_get(push->client, bo) == push) { 763 kref = cli_kref_get(push->client, bo); 764 assert(kref); 765 if (kref->read_domains) 766 flags |= NOUVEAU_BO_RD; 767 if (kref->write_domains) 768 flags |= NOUVEAU_BO_WR; 769 } 770 771 return flags; 772 } 773 774 int 775 nouveau_pushbuf_kick(struct nouveau_pushbuf *push, struct nouveau_object *chan) 776 { 777 if (!push->channel) 778 return pushbuf_submit(push, chan); 779 pushbuf_flush(push); 780 return pushbuf_validate(push, false); 781 } 782
