projects / mesa.git / blob
? search:


ae5f0c4cfe75189b4402bcb1f57b5af3730908bf
[mesa.git] / src / mesa / drivers / dri / radeon / radeon_bo_legacy.c
1 /*
2 * Copyright © 2008 Nicolai Haehnle
3 * Copyright © 2008 Dave Airlie
4 * Copyright © 2008 Jérôme Glisse
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sub license, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
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 NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * The above copyright notice and this permission notice (including the
24 * next paragraph) shall be included in all copies or substantial portions
25 * of the Software.
26 */
27 /*
28 * Authors:
29 * Aapo Tahkola <aet@rasterburn.org>
30 * Nicolai Haehnle <prefect_@gmx.net>
31 * Dave Airlie
32 * Jérôme Glisse <glisse@freedesktop.org>
33 */
34 #include <stdio.h>
35 #include <stddef.h>
36 #include <stdint.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <errno.h>
40 #include <unistd.h>
41 #include <sys/mman.h>
42 #include <sys/ioctl.h>
43 #include "xf86drm.h"
44 #include "texmem.h"
45 #include "main/simple_list.h"
46
47 #include "drm.h"
48 #include "radeon_drm.h"
49 #include "radeon_common.h"
50 #include "radeon_bocs_wrapper.h"
51 #include "radeon_macros.h"
52
53 /* no seriously texmem.c is this screwed up */
54 struct bo_legacy_texture_object {
55 driTextureObject base;
56 struct bo_legacy *parent;
57 };
58
59 struct bo_legacy {
60 struct radeon_bo base;
61 int map_count;
62 uint32_t pending;
63 int is_pending;
64 int static_bo;
65 uint32_t offset;
66 struct bo_legacy_texture_object *tobj;
67 int validated;
68 int dirty;
69 void *ptr;
70 struct bo_legacy *next, *prev;
71 struct bo_legacy *pnext, *pprev;
72 #ifdef RADEON_DEBUG_BO
73 char szBufUsage[16];
74 #endif /* RADEON_DEBUG_BO */
75 };
76
77 struct bo_manager_legacy {
78 struct radeon_bo_manager base;
79 unsigned nhandle;
80 unsigned nfree_handles;
81 unsigned cfree_handles;
82 uint32_t current_age;
83 struct bo_legacy bos;
84 struct bo_legacy pending_bos;
85 uint32_t fb_location;
86 uint32_t texture_offset;
87 unsigned dma_alloc_size;
88 uint32_t dma_buf_count;
89 unsigned cpendings;
90 driTextureObject texture_swapped;
91 driTexHeap *texture_heap;
92 struct radeon_screen *screen;
93 unsigned *free_handles;
94 };
95
96 static void bo_legacy_tobj_destroy(void *data, driTextureObject *t)
97 {
98 struct bo_legacy_texture_object *tobj = (struct bo_legacy_texture_object *)t;
99
100 if (tobj->parent) {
101 tobj->parent->tobj = NULL;
102 tobj->parent->validated = 0;
103 }
104 }
105
106 static void inline clean_handles(struct bo_manager_legacy *bom)
107 {
108 while (bom->cfree_handles > 0 &&
109 !bom->free_handles[bom->cfree_handles - 1])
110 bom->cfree_handles--;
111
112 }
113 static int legacy_new_handle(struct bo_manager_legacy *bom, uint32_t *handle)
114 {
115 uint32_t tmp;
116
117 *handle = 0;
118 if (bom->nhandle == 0xFFFFFFFF) {
119 return -EINVAL;
120 }
121 if (bom->cfree_handles > 0) {
122 tmp = bom->free_handles[--bom->cfree_handles];
123 clean_handles(bom);
124 } else {
125 bom->cfree_handles = 0;
126 tmp = bom->nhandle++;
127 }
128 assert(tmp);
129 *handle = tmp;
130 return 0;
131 }
132
133 static int legacy_free_handle(struct bo_manager_legacy *bom, uint32_t handle)
134 {
135 uint32_t *handles;
136
137 if (!handle) {
138 return 0;
139 }
140 if (handle == (bom->nhandle - 1)) {
141 int i;
142
143 bom->nhandle--;
144 for (i = bom->cfree_handles - 1; i >= 0; i--) {
145 if (bom->free_handles[i] == (bom->nhandle - 1)) {
146 bom->nhandle--;
147 bom->free_handles[i] = 0;
148 }
149 }
150 clean_handles(bom);
151 return 0;
152 }
153 if (bom->cfree_handles < bom->nfree_handles) {
154 bom->free_handles[bom->cfree_handles++] = handle;
155 return 0;
156 }
157 bom->nfree_handles += 0x100;
158 handles = (uint32_t*)realloc(bom->free_handles, bom->nfree_handles * 4);
159 if (handles == NULL) {
160 bom->nfree_handles -= 0x100;
161 return -ENOMEM;
162 }
163 bom->free_handles = handles;
164 bom->free_handles[bom->cfree_handles++] = handle;
165 return 0;
166 }
167
168 static void legacy_get_current_age(struct bo_manager_legacy *boml)
169 {
170 drm_radeon_getparam_t gp;
171 unsigned char *RADEONMMIO = NULL;
172 int r;
173
174 if ( IS_R300_CLASS(boml->screen)
175 || IS_R600_CLASS(boml->screen) )
176 {
177 gp.param = RADEON_PARAM_LAST_CLEAR;
178 gp.value = (int *)&boml->current_age;
179 r = drmCommandWriteRead(boml->base.fd, DRM_RADEON_GETPARAM,
180 &gp, sizeof(gp));
181 if (r) {
182 fprintf(stderr, "%s: drmRadeonGetParam: %d\n", __FUNCTION__, r);
183 exit(1);
184 }
185 }
186 else {
187 RADEONMMIO = boml->screen->mmio.map;
188 boml->current_age = boml->screen->scratch[3];
189 boml->current_age = INREG(RADEON_GUI_SCRATCH_REG3);
190 }
191 }
192
193 static int legacy_is_pending(struct radeon_bo *bo)
194 {
195 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
196 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
197
198 if (bo_legacy->is_pending <= 0) {
199 bo_legacy->is_pending = 0;
200 return 0;
201 }
202 if (boml->current_age >= bo_legacy->pending) {
203 if (boml->pending_bos.pprev == bo_legacy) {
204 boml->pending_bos.pprev = bo_legacy->pprev;
205 }
206 bo_legacy->pprev->pnext = bo_legacy->pnext;
207 if (bo_legacy->pnext) {
208 bo_legacy->pnext->pprev = bo_legacy->pprev;
209 }
210 assert(bo_legacy->is_pending <= bo->cref);
211 while (bo_legacy->is_pending--) {
212 bo = radeon_bo_unref(bo);
213 if (!bo)
214 break;
215 }
216 if (bo)
217 bo_legacy->is_pending = 0;
218 boml->cpendings--;
219 return 0;
220 }
221 return 1;
222 }
223
224 static int legacy_wait_pending(struct radeon_bo *bo)
225 {
226 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
227 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
228
229 if (!bo_legacy->is_pending) {
230 return 0;
231 }
232 /* FIXME: lockup and userspace busy looping that's all the folks */
233 legacy_get_current_age(boml);
234 while (legacy_is_pending(bo)) {
235 usleep(10);
236 legacy_get_current_age(boml);
237 }
238 return 0;
239 }
240
241 static void legacy_track_pending(struct bo_manager_legacy *boml, int debug)
242 {
243 struct bo_legacy *bo_legacy;
244 struct bo_legacy *next;
245
246 legacy_get_current_age(boml);
247 bo_legacy = boml->pending_bos.pnext;
248 while (bo_legacy) {
249 if (debug)
250 fprintf(stderr,"pending %p %d %d %d\n", bo_legacy, bo_legacy->base.size,
251 boml->current_age, bo_legacy->pending);
252 next = bo_legacy->pnext;
253 if (legacy_is_pending(&(bo_legacy->base))) {
254 }
255 bo_legacy = next;
256 }
257 }
258
259 static int legacy_wait_any_pending(struct bo_manager_legacy *boml)
260 {
261 struct bo_legacy *bo_legacy;
262
263 legacy_get_current_age(boml);
264 bo_legacy = boml->pending_bos.pnext;
265 if (!bo_legacy)
266 return -1;
267 legacy_wait_pending(&bo_legacy->base);
268 return 0;
269 }
270
271 static void legacy_kick_all_buffers(struct bo_manager_legacy *boml)
272 {
273 struct bo_legacy *legacy;
274
275 legacy = boml->bos.next;
276 while (legacy != &boml->bos) {
277 if (legacy->tobj) {
278 if (legacy->validated) {
279 driDestroyTextureObject(&legacy->tobj->base);
280 legacy->tobj = 0;
281 legacy->validated = 0;
282 }
283 }
284 legacy = legacy->next;
285 }
286 }
287
288 static struct bo_legacy *bo_allocate(struct bo_manager_legacy *boml,
289 uint32_t size,
290 uint32_t alignment,
291 uint32_t domains,
292 #ifdef RADEON_DEBUG_BO
293 uint32_t flags,
294 char * szBufUsage)
295 #else
296 uint32_t flags)
297 #endif /* RADEON_DEBUG_BO */
298 {
299 struct bo_legacy *bo_legacy;
300 static int pgsize;
301
302 if (pgsize == 0)
303 pgsize = getpagesize() - 1;
304
305 size = (size + pgsize) & ~pgsize;
306
307 bo_legacy = (struct bo_legacy*)calloc(1, sizeof(struct bo_legacy));
308 if (bo_legacy == NULL) {
309 return NULL;
310 }
311 bo_legacy->base.bom = (struct radeon_bo_manager*)boml;
312 bo_legacy->base.handle = 0;
313 bo_legacy->base.size = size;
314 bo_legacy->base.alignment = alignment;
315 bo_legacy->base.domains = domains;
316 bo_legacy->base.flags = flags;
317 bo_legacy->base.ptr = NULL;
318 bo_legacy->map_count = 0;
319 bo_legacy->next = NULL;
320 bo_legacy->prev = NULL;
321 bo_legacy->pnext = NULL;
322 bo_legacy->pprev = NULL;
323 bo_legacy->next = boml->bos.next;
324 bo_legacy->prev = &boml->bos;
325 boml->bos.next = bo_legacy;
326 if (bo_legacy->next) {
327 bo_legacy->next->prev = bo_legacy;
328 }
329
330 #ifdef RADEON_DEBUG_BO
331 sprintf(bo_legacy->szBufUsage, "%s", szBufUsage);
332 #endif /* RADEON_DEBUG_BO */
333
334 return bo_legacy;
335 }
336
337 static int bo_dma_alloc(struct radeon_bo *bo)
338 {
339 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
340 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
341 drm_radeon_mem_alloc_t alloc;
342 unsigned size;
343 int base_offset;
344 int r;
345
346 /* align size on 4Kb */
347 size = (((4 * 1024) - 1) + bo->size) & ~((4 * 1024) - 1);
348 alloc.region = RADEON_MEM_REGION_GART;
349 alloc.alignment = bo_legacy->base.alignment;
350 alloc.size = size;
351 alloc.region_offset = &base_offset;
352 r = drmCommandWriteRead(bo->bom->fd,
353 DRM_RADEON_ALLOC,
354 &alloc,
355 sizeof(alloc));
356 if (r) {
357 /* ptr is set to NULL if dma allocation failed */
358 bo_legacy->ptr = NULL;
359 return r;
360 }
361 bo_legacy->ptr = boml->screen->gartTextures.map + base_offset;
362 bo_legacy->offset = boml->screen->gart_texture_offset + base_offset;
363 bo->size = size;
364 boml->dma_alloc_size += size;
365 boml->dma_buf_count++;
366 return 0;
367 }
368
369 static int bo_dma_free(struct radeon_bo *bo)
370 {
371 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
372 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
373 drm_radeon_mem_free_t memfree;
374 int r;
375
376 if (bo_legacy->ptr == NULL) {
377 /* ptr is set to NULL if dma allocation failed */
378 return 0;
379 }
380 legacy_get_current_age(boml);
381 memfree.region = RADEON_MEM_REGION_GART;
382 memfree.region_offset = bo_legacy->offset;
383 memfree.region_offset -= boml->screen->gart_texture_offset;
384 r = drmCommandWrite(boml->base.fd,
385 DRM_RADEON_FREE,
386 &memfree,
387 sizeof(memfree));
388 if (r) {
389 fprintf(stderr, "Failed to free bo[%p] at %08x\n",
390 &bo_legacy->base, memfree.region_offset);
391 fprintf(stderr, "ret = %s\n", strerror(-r));
392 return r;
393 }
394 boml->dma_alloc_size -= bo_legacy->base.size;
395 boml->dma_buf_count--;
396 return 0;
397 }
398
399 static void bo_free(struct bo_legacy *bo_legacy)
400 {
401 struct bo_manager_legacy *boml;
402
403 if (bo_legacy == NULL) {
404 return;
405 }
406 boml = (struct bo_manager_legacy *)bo_legacy->base.bom;
407 bo_legacy->prev->next = bo_legacy->next;
408 if (bo_legacy->next) {
409 bo_legacy->next->prev = bo_legacy->prev;
410 }
411 if (!bo_legacy->static_bo) {
412 legacy_free_handle(boml, bo_legacy->base.handle);
413 if (bo_legacy->base.domains & RADEON_GEM_DOMAIN_GTT) {
414 /* dma buffers */
415 bo_dma_free(&bo_legacy->base);
416 } else {
417 driDestroyTextureObject(&bo_legacy->tobj->base);
418 bo_legacy->tobj = NULL;
419 /* free backing store */
420 free(bo_legacy->ptr);
421 }
422 }
423 memset(bo_legacy, 0 , sizeof(struct bo_legacy));
424 free(bo_legacy);
425 }
426
427 static struct radeon_bo *bo_open(struct radeon_bo_manager *bom,
428 uint32_t handle,
429 uint32_t size,
430 uint32_t alignment,
431 uint32_t domains,
432 #ifdef RADEON_DEBUG_BO
433 uint32_t flags,
434 char * szBufUsage)
435 #else
436 uint32_t flags)
437 #endif /* RADEON_DEBUG_BO */
438 {
439 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bom;
440 struct bo_legacy *bo_legacy;
441 int r;
442
443 if (handle) {
444 bo_legacy = boml->bos.next;
445 while (bo_legacy) {
446 if (bo_legacy->base.handle == handle) {
447 radeon_bo_ref(&(bo_legacy->base));
448 return (struct radeon_bo*)bo_legacy;
449 }
450 bo_legacy = bo_legacy->next;
451 }
452 return NULL;
453 }
454 #ifdef RADEON_DEBUG_BO
455 bo_legacy = bo_allocate(boml, size, alignment, domains, flags, szBufUsage);
456 #else
457 bo_legacy = bo_allocate(boml, size, alignment, domains, flags);
458 #endif /* RADEON_DEBUG_BO */
459 bo_legacy->static_bo = 0;
460 r = legacy_new_handle(boml, &bo_legacy->base.handle);
461 if (r) {
462 bo_free(bo_legacy);
463 return NULL;
464 }
465 if (bo_legacy->base.domains & RADEON_GEM_DOMAIN_GTT)
466 {
467 retry:
468 legacy_track_pending(boml, 0);
469 /* dma buffers */
470
471 r = bo_dma_alloc(&(bo_legacy->base));
472 if (r)
473 {
474 if (legacy_wait_any_pending(boml) == -1)
475 {
476 bo_free(bo_legacy);
477 return NULL;
478 }
479 goto retry;
480 return NULL;
481 }
482 }
483 else
484 {
485 bo_legacy->ptr = malloc(bo_legacy->base.size);
486 if (bo_legacy->ptr == NULL) {
487 bo_free(bo_legacy);
488 return NULL;
489 }
490 }
491 radeon_bo_ref(&(bo_legacy->base));
492
493 return (struct radeon_bo*)bo_legacy;
494 }
495
496 static void bo_ref(struct radeon_bo *bo)
497 {
498 }
499
500 static struct radeon_bo *bo_unref(struct radeon_bo *bo)
501 {
502 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
503
504 if (bo->cref <= 0) {
505 bo_legacy->prev->next = bo_legacy->next;
506 if (bo_legacy->next) {
507 bo_legacy->next->prev = bo_legacy->prev;
508 }
509 if (!bo_legacy->is_pending) {
510 bo_free(bo_legacy);
511 }
512 return NULL;
513 }
514 return bo;
515 }
516
517 static int bo_map(struct radeon_bo *bo, int write)
518 {
519 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
520 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
521
522 legacy_wait_pending(bo);
523 bo_legacy->validated = 0;
524 bo_legacy->dirty = 1;
525 bo_legacy->map_count++;
526 bo->ptr = bo_legacy->ptr;
527 /* Read the first pixel in the frame buffer. This should
528 * be a noop, right? In fact without this conform fails as reading
529 * from the framebuffer sometimes produces old results -- the
530 * on-card read cache gets mixed up and doesn't notice that the
531 * framebuffer has been updated.
532 *
533 * Note that we should probably be reading some otherwise unused
534 * region of VRAM, otherwise we might get incorrect results when
535 * reading pixels from the top left of the screen.
536 *
537 * I found this problem on an R420 with glean's texCube test.
538 * Note that the R200 span code also *writes* the first pixel in the
539 * framebuffer, but I've found this to be unnecessary.
540 * -- Nicolai Hähnle, June 2008
541 */
542 if (!(bo->domains & RADEON_GEM_DOMAIN_GTT)) {
543 int p;
544 volatile int *buf = (int*)boml->screen->driScreen->pFB;
545 p = *buf;
546 }
547
548 return 0;
549 }
550
551 static int bo_unmap(struct radeon_bo *bo)
552 {
553 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
554
555 if (--bo_legacy->map_count > 0)
556 {
557 return 0;
558 }
559
560 bo->ptr = NULL;
561
562 return 0;
563 }
564
565 static struct radeon_bo_funcs bo_legacy_funcs = {
566 bo_open,
567 bo_ref,
568 bo_unref,
569 bo_map,
570 bo_unmap
571 };
572
573 static int bo_vram_validate(struct radeon_bo *bo,
574 uint32_t *soffset,
575 uint32_t *eoffset)
576 {
577 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
578 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
579 int r;
580 int retry_count = 0, pending_retry = 0;
581
582 if (!bo_legacy->tobj) {
583 bo_legacy->tobj = CALLOC(sizeof(struct bo_legacy_texture_object));
584 bo_legacy->tobj->parent = bo_legacy;
585 make_empty_list(&bo_legacy->tobj->base);
586 bo_legacy->tobj->base.totalSize = bo->size;
587 retry:
588 r = driAllocateTexture(&boml->texture_heap, 1,
589 &bo_legacy->tobj->base);
590 if (r) {
591 pending_retry = 0;
592 while(boml->cpendings && pending_retry++ < 10000) {
593 legacy_track_pending(boml, 0);
594 retry_count++;
595 if (retry_count > 2) {
596 free(bo_legacy->tobj);
597 bo_legacy->tobj = NULL;
598 fprintf(stderr, "Ouch! vram_validate failed %d\n", r);
599 return -1;
600 }
601 goto retry;
602 }
603 }
604 bo_legacy->offset = boml->texture_offset +
605 bo_legacy->tobj->base.memBlock->ofs;
606 bo_legacy->dirty = 1;
607 }
608
609 assert(bo_legacy->tobj->base.memBlock);
610
611 if (bo_legacy->tobj)
612 driUpdateTextureLRU(&bo_legacy->tobj->base);
613
614 if (bo_legacy->dirty || bo_legacy->tobj->base.dirty_images[0]) {
615 if (IS_R600_CLASS(boml->screen)) {
616 char *src = bo_legacy->ptr;
617 char *dst = (char *) boml->screen->driScreen->pFB +
618 (bo_legacy->offset - boml->fb_location);
619
620 /* FIXME: alignment, pitch, etc. */
621 r600_sw_blit(src, 0, dst, 0, 0, 0, 1, 1, bo->size);
622 } else {
623 /* Copy to VRAM using a blit.
624 * All memory is 4K aligned. We're using 1024 pixels wide blits.
625 */
626 drm_radeon_texture_t tex;
627 drm_radeon_tex_image_t tmp;
628 int ret;
629
630 tex.offset = bo_legacy->offset;
631 tex.image = &tmp;
632 assert(!(tex.offset & 1023));
633
634 tmp.x = 0;
635 tmp.y = 0;
636 if (bo->size < 4096) {
637 tmp.width = (bo->size + 3) / 4;
638 tmp.height = 1;
639 } else {
640 tmp.width = 1024;
641 tmp.height = (bo->size + 4095) / 4096;
642 }
643 tmp.data = bo_legacy->ptr;
644 tex.format = RADEON_TXFORMAT_ARGB8888;
645 tex.width = tmp.width;
646 tex.height = tmp.height;
647 tex.pitch = MAX2(tmp.width / 16, 1);
648 do {
649 ret = drmCommandWriteRead(bo->bom->fd,
650 DRM_RADEON_TEXTURE,
651 &tex,
652 sizeof(drm_radeon_texture_t));
653 if (ret) {
654 if (RADEON_DEBUG & DEBUG_IOCTL)
655 fprintf(stderr, "DRM_RADEON_TEXTURE: again!\n");
656 usleep(1);
657 }
658 } while (ret == -EAGAIN);
659 }
660 bo_legacy->dirty = 0;
661 bo_legacy->tobj->base.dirty_images[0] = 0;
662 }
663 return 0;
664 }
665
666 /*
667 * radeon_bo_legacy_validate -
668 * returns:
669 * 0 - all good
670 * -EINVAL - mapped buffer can't be validated
671 * -EAGAIN - restart validation we've kicked all the buffers out
672 */
673 int radeon_bo_legacy_validate(struct radeon_bo *bo,
674 uint32_t *soffset,
675 uint32_t *eoffset)
676 {
677 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
678 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
679 int r;
680 int retries = 0;
681
682 if (bo_legacy->map_count) {
683 #ifdef RADEON_DEBUG_BO
684 fprintf(stderr, "bo(%p, %d, %s) is mapped (%d) can't valide it.\n",
685 bo, bo->size, bo_legacy->szBufUsage, bo_legacy->map_count);
686 #else
687 fprintf(stderr, "bo(%p, %d) is mapped (%d) can't valide it.\n",
688 bo, bo->size, bo_legacy->map_count);
689 #endif /* RADEON_DEBUG_BO */
690
691 return -EINVAL;
692 }
693 if (bo_legacy->static_bo || bo_legacy->validated) {
694 *soffset = bo_legacy->offset;
695 *eoffset = bo_legacy->offset + bo->size;
696
697 return 0;
698 }
699 if (!(bo->domains & RADEON_GEM_DOMAIN_GTT)) {
700
701 r = bo_vram_validate(bo, soffset, eoffset);
702 if (r) {
703 legacy_track_pending(boml, 0);
704 legacy_kick_all_buffers(boml);
705 retries++;
706 if (retries == 2) {
707 fprintf(stderr,"legacy bo: failed to get relocations into aperture\n");
708 assert(0);
709 exit(-1);
710 }
711 return -EAGAIN;
712 }
713 }
714 *soffset = bo_legacy->offset;
715 *eoffset = bo_legacy->offset + bo->size;
716 bo_legacy->validated = 1;
717
718 return 0;
719 }
720
721 void radeon_bo_legacy_pending(struct radeon_bo *bo, uint32_t pending)
722 {
723 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bo->bom;
724 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
725
726 bo_legacy->pending = pending;
727 bo_legacy->is_pending++;
728 /* add to pending list */
729 radeon_bo_ref(bo);
730 if (bo_legacy->is_pending > 1) {
731 return;
732 }
733 bo_legacy->pprev = boml->pending_bos.pprev;
734 bo_legacy->pnext = NULL;
735 bo_legacy->pprev->pnext = bo_legacy;
736 boml->pending_bos.pprev = bo_legacy;
737 boml->cpendings++;
738 }
739
740 void radeon_bo_manager_legacy_dtor(struct radeon_bo_manager *bom)
741 {
742 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bom;
743 struct bo_legacy *bo_legacy;
744
745 if (bom == NULL) {
746 return;
747 }
748 bo_legacy = boml->bos.next;
749 while (bo_legacy) {
750 struct bo_legacy *next;
751
752 next = bo_legacy->next;
753 bo_free(bo_legacy);
754 bo_legacy = next;
755 }
756 driDestroyTextureHeap(boml->texture_heap);
757 free(boml->free_handles);
758 free(boml);
759 }
760
761 static struct bo_legacy *radeon_legacy_bo_alloc_static(struct bo_manager_legacy *bom,
762 int size,
763 #ifdef RADEON_DEBUG_BO
764 uint32_t offset,
765 char * szBufUsage)
766 #else
767 uint32_t offset)
768 #endif /* RADEON_DEBUG_BO */
769 {
770 struct bo_legacy *bo;
771
772 #ifdef RADEON_DEBUG_BO
773 bo = bo_allocate(bom, size, 0, RADEON_GEM_DOMAIN_VRAM, 0, szBufUsage);
774 #else
775 bo = bo_allocate(bom, size, 0, RADEON_GEM_DOMAIN_VRAM, 0);
776 #endif /* RADEON_DEBUG_BO */
777 if (bo == NULL)
778 return NULL;
779 bo->static_bo = 1;
780 bo->offset = offset + bom->fb_location;
781 bo->base.handle = bo->offset;
782 bo->ptr = bom->screen->driScreen->pFB + offset;
783 if (bo->base.handle > bom->nhandle) {
784 bom->nhandle = bo->base.handle + 1;
785 }
786 radeon_bo_ref(&(bo->base));
787 return bo;
788 }
789
790 struct radeon_bo_manager *radeon_bo_manager_legacy_ctor(struct radeon_screen *scrn)
791 {
792 struct bo_manager_legacy *bom;
793 struct bo_legacy *bo;
794 unsigned size;
795
796 bom = (struct bo_manager_legacy*)
797 calloc(1, sizeof(struct bo_manager_legacy));
798 if (bom == NULL) {
799 return NULL;
800 }
801
802 make_empty_list(&bom->texture_swapped);
803
804 bom->texture_heap = driCreateTextureHeap(0,
805 bom,
806 scrn->texSize[0],
807 12,
808 RADEON_NR_TEX_REGIONS,
809 (drmTextureRegionPtr)scrn->sarea->tex_list[0],
810 &scrn->sarea->tex_age[0],
811 &bom->texture_swapped,
812 sizeof(struct bo_legacy_texture_object),
813 &bo_legacy_tobj_destroy);
814 bom->texture_offset = scrn->texOffset[0];
815
816 bom->base.funcs = &bo_legacy_funcs;
817 bom->base.fd = scrn->driScreen->fd;
818 bom->bos.next = NULL;
819 bom->bos.prev = NULL;
820 bom->pending_bos.pprev = &bom->pending_bos;
821 bom->pending_bos.pnext = NULL;
822 bom->screen = scrn;
823 bom->fb_location = scrn->fbLocation;
824 bom->nhandle = 1;
825 bom->cfree_handles = 0;
826 bom->nfree_handles = 0x400;
827 bom->free_handles = (uint32_t*)malloc(bom->nfree_handles * 4);
828 if (bom->free_handles == NULL) {
829 radeon_bo_manager_legacy_dtor((struct radeon_bo_manager*)bom);
830 return NULL;
831 }
832
833 /* biggest framebuffer size */
834 size = 4096*4096*4;
835
836 /* allocate front */
837 #ifdef RADEON_DEBUG_BO
838 bo = radeon_legacy_bo_alloc_static(bom, size, bom->screen->frontOffset, "FRONT BUF");
839 #else
840 bo = radeon_legacy_bo_alloc_static(bom, size, bom->screen->frontOffset);
841 #endif /* RADEON_DEBUG_BO */
842 if (!bo) {
843 radeon_bo_manager_legacy_dtor((struct radeon_bo_manager*)bom);
844 return NULL;
845 }
846 if (scrn->sarea->tiling_enabled) {
847 bo->base.flags = RADEON_BO_FLAGS_MACRO_TILE;
848 }
849
850 /* allocate back */
851 #ifdef RADEON_DEBUG_BO
852 bo = radeon_legacy_bo_alloc_static(bom, size, bom->screen->backOffset, "BACK BUF");
853 #else
854 bo = radeon_legacy_bo_alloc_static(bom, size, bom->screen->backOffset);
855 #endif /* RADEON_DEBUG_BO */
856 if (!bo) {
857 radeon_bo_manager_legacy_dtor((struct radeon_bo_manager*)bom);
858 return NULL;
859 }
860 if (scrn->sarea->tiling_enabled) {
861 bo->base.flags = RADEON_BO_FLAGS_MACRO_TILE;
862 }
863
864 /* allocate depth */
865 #ifdef RADEON_DEBUG_BO
866 bo = radeon_legacy_bo_alloc_static(bom, size, bom->screen->depthOffset, "Z BUF");
867 #else
868 bo = radeon_legacy_bo_alloc_static(bom, size, bom->screen->depthOffset);
869 #endif /* RADEON_DEBUG_BO */
870 if (!bo) {
871 radeon_bo_manager_legacy_dtor((struct radeon_bo_manager*)bom);
872 return NULL;
873 }
874 bo->base.flags = 0;
875 if (scrn->sarea->tiling_enabled) {
876 bo->base.flags |= RADEON_BO_FLAGS_MACRO_TILE;
877 bo->base.flags |= RADEON_BO_FLAGS_MICRO_TILE;
878 }
879 return (struct radeon_bo_manager*)bom;
880 }
881
882 void radeon_bo_legacy_texture_age(struct radeon_bo_manager *bom)
883 {
884 struct bo_manager_legacy *boml = (struct bo_manager_legacy *)bom;
885 DRI_AGE_TEXTURES(boml->texture_heap);
886 }
887
888 unsigned radeon_bo_legacy_relocs_size(struct radeon_bo *bo)
889 {
890 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
891
892 if (bo_legacy->static_bo || (bo->domains & RADEON_GEM_DOMAIN_GTT)) {
893 return 0;
894 }
895 return bo->size;
896 }
897
898 int radeon_legacy_bo_is_static(struct radeon_bo *bo)
899 {
900 struct bo_legacy *bo_legacy = (struct bo_legacy*)bo;
901 return bo_legacy->static_bo;
902 }
903