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 AUTHORS OR COPYRIGHT HOLDERS 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
26 #include "util/u_format.h"
27 #include "util/u_inlines.h"
28 #include "util/u_surface.h"
29
30 #include "nv_m2mf.xml.h"
31 #include "nv_object.xml.h"
32 #include "nv30/nv30_screen.h"
33 #include "nv30/nv30_context.h"
34 #include "nv30/nv30_resource.h"
35 #include "nv30/nv30_transfer.h"
36
37 static inline unsigned
layer_offset(struct pipe_resource * pt,unsigned level,unsigned layer)38 layer_offset(struct pipe_resource *pt, unsigned level, unsigned layer)
39 {
40 struct nv30_miptree *mt = nv30_miptree(pt);
41 struct nv30_miptree_level *lvl = &mt->level[level];
42
43 if (pt->target == PIPE_TEXTURE_CUBE)
44 return (layer * mt->layer_size) + lvl->offset;
45
46 return lvl->offset + (layer * lvl->zslice_size);
47 }
48
49 static boolean
nv30_miptree_get_handle(struct pipe_screen * pscreen,struct pipe_resource * pt,struct winsys_handle * handle)50 nv30_miptree_get_handle(struct pipe_screen *pscreen,
51 struct pipe_resource *pt,
52 struct winsys_handle *handle)
53 {
54 struct nv30_miptree *mt = nv30_miptree(pt);
55 unsigned stride;
56
57 if (!mt || !mt->base.bo)
58 return false;
59
60 stride = mt->level[0].pitch;
61
62 return nouveau_screen_bo_get_handle(pscreen, mt->base.bo, stride, handle);
63 }
64
65 static void
nv30_miptree_destroy(struct pipe_screen * pscreen,struct pipe_resource * pt)66 nv30_miptree_destroy(struct pipe_screen *pscreen, struct pipe_resource *pt)
67 {
68 struct nv30_miptree *mt = nv30_miptree(pt);
69
70 nouveau_bo_ref(NULL, &mt->base.bo);
71 FREE(mt);
72 }
73
74 struct nv30_transfer {
75 struct pipe_transfer base;
76 struct nv30_rect img;
77 struct nv30_rect tmp;
78 unsigned nblocksx;
79 unsigned nblocksy;
80 };
81
82 static inline struct nv30_transfer *
nv30_transfer(struct pipe_transfer * ptx)83 nv30_transfer(struct pipe_transfer *ptx)
84 {
85 return (struct nv30_transfer *)ptx;
86 }
87
88 static inline void
define_rect(struct pipe_resource * pt,unsigned level,unsigned z,unsigned x,unsigned y,unsigned w,unsigned h,struct nv30_rect * rect)89 define_rect(struct pipe_resource *pt, unsigned level, unsigned z,
90 unsigned x, unsigned y, unsigned w, unsigned h,
91 struct nv30_rect *rect)
92 {
93 struct nv30_miptree *mt = nv30_miptree(pt);
94 struct nv30_miptree_level *lvl = &mt->level[level];
95
96 rect->w = u_minify(pt->width0, level) << mt->ms_x;
97 rect->w = util_format_get_nblocksx(pt->format, rect->w);
98 rect->h = u_minify(pt->height0, level) << mt->ms_y;
99 rect->h = util_format_get_nblocksy(pt->format, rect->h);
100 rect->d = 1;
101 rect->z = 0;
102 if (mt->swizzled) {
103 if (pt->target == PIPE_TEXTURE_3D) {
104 rect->d = u_minify(pt->depth0, level);
105 rect->z = z; z = 0;
106 }
107 rect->pitch = 0;
108 } else {
109 rect->pitch = lvl->pitch;
110 }
111
112 rect->bo = mt->base.bo;
113 rect->domain = NOUVEAU_BO_VRAM;
114 rect->offset = layer_offset(pt, level, z);
115 rect->cpp = util_format_get_blocksize(pt->format);
116
117 rect->x0 = util_format_get_nblocksx(pt->format, x) << mt->ms_x;
118 rect->y0 = util_format_get_nblocksy(pt->format, y) << mt->ms_y;
119 rect->x1 = rect->x0 + (w << mt->ms_x);
120 rect->y1 = rect->y0 + (h << mt->ms_y);
121 }
122
123 void
nv30_resource_copy_region(struct pipe_context * pipe,struct pipe_resource * dstres,unsigned dst_level,unsigned dstx,unsigned dsty,unsigned dstz,struct pipe_resource * srcres,unsigned src_level,const struct pipe_box * src_box)124 nv30_resource_copy_region(struct pipe_context *pipe,
125 struct pipe_resource *dstres, unsigned dst_level,
126 unsigned dstx, unsigned dsty, unsigned dstz,
127 struct pipe_resource *srcres, unsigned src_level,
128 const struct pipe_box *src_box)
129 {
130 struct nv30_context *nv30 = nv30_context(pipe);
131 struct nv30_rect src, dst;
132
133 if (dstres->target == PIPE_BUFFER && srcres->target == PIPE_BUFFER) {
134 nouveau_copy_buffer(&nv30->base,
135 nv04_resource(dstres), dstx,
136 nv04_resource(srcres), src_box->x, src_box->width);
137 return;
138 }
139
140 define_rect(srcres, src_level, src_box->z, src_box->x, src_box->y,
141 src_box->width, src_box->height, &src);
142 define_rect(dstres, dst_level, dstz, dstx, dsty,
143 src_box->width, src_box->height, &dst);
144
145 nv30_transfer_rect(nv30, NEAREST, &src, &dst);
146 }
147
148 static void
nv30_resource_resolve(struct nv30_context * nv30,const struct pipe_blit_info * info)149 nv30_resource_resolve(struct nv30_context *nv30,
150 const struct pipe_blit_info *info)
151 {
152 struct nv30_miptree *src_mt = nv30_miptree(info->src.resource);
153 struct nv30_rect src, dst;
154 unsigned x, x0, x1, y, y1, w, h;
155
156 define_rect(info->src.resource, 0, info->src.box.z, info->src.box.x,
157 info->src.box.y, info->src.box.width, info->src.box.height, &src);
158 define_rect(info->dst.resource, 0, info->dst.box.z, info->dst.box.x,
159 info->dst.box.y, info->dst.box.width, info->dst.box.height, &dst);
160
161 x0 = src.x0;
162 x1 = src.x1;
163 y1 = src.y1;
164
165 /* On nv3x we must use sifm which is restricted to 1024x1024 tiles */
166 for (y = src.y0; y < y1; y += h) {
167 h = y1 - y;
168 if (h > 1024)
169 h = 1024;
170
171 src.y0 = 0;
172 src.y1 = h;
173 src.h = h;
174
175 dst.y1 = dst.y0 + (h >> src_mt->ms_y);
176 dst.h = h >> src_mt->ms_y;
177
178 for (x = x0; x < x1; x += w) {
179 w = x1 - x;
180 if (w > 1024)
181 w = 1024;
182
183 src.offset = y * src.pitch + x * src.cpp;
184 src.x0 = 0;
185 src.x1 = w;
186 src.w = w;
187
188 dst.offset = (y >> src_mt->ms_y) * dst.pitch +
189 (x >> src_mt->ms_x) * dst.cpp;
190 dst.x1 = dst.x0 + (w >> src_mt->ms_x);
191 dst.w = w >> src_mt->ms_x;
192
193 nv30_transfer_rect(nv30, BILINEAR, &src, &dst);
194 }
195 }
196 }
197
198 void
nv30_blit(struct pipe_context * pipe,const struct pipe_blit_info * blit_info)199 nv30_blit(struct pipe_context *pipe,
200 const struct pipe_blit_info *blit_info)
201 {
202 struct nv30_context *nv30 = nv30_context(pipe);
203 struct pipe_blit_info info = *blit_info;
204
205 if (info.src.resource->nr_samples > 1 &&
206 info.dst.resource->nr_samples <= 1 &&
207 !util_format_is_depth_or_stencil(info.src.resource->format) &&
208 !util_format_is_pure_integer(info.src.resource->format)) {
209 nv30_resource_resolve(nv30, blit_info);
210 return;
211 }
212
213 if (util_try_blit_via_copy_region(pipe, &info)) {
214 return; /* done */
215 }
216
217 if (info.mask & PIPE_MASK_S) {
218 debug_printf("nv30: cannot blit stencil, skipping\n");
219 info.mask &= ~PIPE_MASK_S;
220 }
221
222 if (!util_blitter_is_blit_supported(nv30->blitter, &info)) {
223 debug_printf("nv30: blit unsupported %s -> %s\n",
224 util_format_short_name(info.src.resource->format),
225 util_format_short_name(info.dst.resource->format));
226 return;
227 }
228
229 /* XXX turn off occlusion queries */
230
231 util_blitter_save_vertex_buffer_slot(nv30->blitter, nv30->vtxbuf);
232 util_blitter_save_vertex_elements(nv30->blitter, nv30->vertex);
233 util_blitter_save_vertex_shader(nv30->blitter, nv30->vertprog.program);
234 util_blitter_save_rasterizer(nv30->blitter, nv30->rast);
235 util_blitter_save_viewport(nv30->blitter, &nv30->viewport);
236 util_blitter_save_scissor(nv30->blitter, &nv30->scissor);
237 util_blitter_save_fragment_shader(nv30->blitter, nv30->fragprog.program);
238 util_blitter_save_blend(nv30->blitter, nv30->blend);
239 util_blitter_save_depth_stencil_alpha(nv30->blitter,
240 nv30->zsa);
241 util_blitter_save_stencil_ref(nv30->blitter, &nv30->stencil_ref);
242 util_blitter_save_sample_mask(nv30->blitter, nv30->sample_mask);
243 util_blitter_save_framebuffer(nv30->blitter, &nv30->framebuffer);
244 util_blitter_save_fragment_sampler_states(nv30->blitter,
245 nv30->fragprog.num_samplers,
246 (void**)nv30->fragprog.samplers);
247 util_blitter_save_fragment_sampler_views(nv30->blitter,
248 nv30->fragprog.num_textures, nv30->fragprog.textures);
249 util_blitter_save_render_condition(nv30->blitter, nv30->render_cond_query,
250 nv30->render_cond_cond, nv30->render_cond_mode);
251 util_blitter_blit(nv30->blitter, &info);
252 }
253
254 void
nv30_flush_resource(struct pipe_context * pipe,struct pipe_resource * resource)255 nv30_flush_resource(struct pipe_context *pipe,
256 struct pipe_resource *resource)
257 {
258 }
259
260 static void *
nv30_miptree_transfer_map(struct pipe_context * pipe,struct pipe_resource * pt,unsigned level,unsigned usage,const struct pipe_box * box,struct pipe_transfer ** ptransfer)261 nv30_miptree_transfer_map(struct pipe_context *pipe, struct pipe_resource *pt,
262 unsigned level, unsigned usage,
263 const struct pipe_box *box,
264 struct pipe_transfer **ptransfer)
265 {
266 struct nv30_context *nv30 = nv30_context(pipe);
267 struct nouveau_device *dev = nv30->screen->base.device;
268 struct nv30_transfer *tx;
269 unsigned access = 0;
270 int ret;
271
272 tx = CALLOC_STRUCT(nv30_transfer);
273 if (!tx)
274 return NULL;
275 pipe_resource_reference(&tx->base.resource, pt);
276 tx->base.level = level;
277 tx->base.usage = usage;
278 tx->base.box = *box;
279 tx->base.stride = align(util_format_get_nblocksx(pt->format, box->width) *
280 util_format_get_blocksize(pt->format), 64);
281 tx->base.layer_stride = util_format_get_nblocksy(pt->format, box->height) *
282 tx->base.stride;
283
284 tx->nblocksx = util_format_get_nblocksx(pt->format, box->width);
285 tx->nblocksy = util_format_get_nblocksy(pt->format, box->height);
286
287 define_rect(pt, level, box->z, box->x, box->y,
288 tx->nblocksx, tx->nblocksy, &tx->img);
289
290 ret = nouveau_bo_new(dev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0,
291 tx->base.layer_stride, NULL, &tx->tmp.bo);
292 if (ret) {
293 pipe_resource_reference(&tx->base.resource, NULL);
294 FREE(tx);
295 return NULL;
296 }
297
298 tx->tmp.domain = NOUVEAU_BO_GART;
299 tx->tmp.offset = 0;
300 tx->tmp.pitch = tx->base.stride;
301 tx->tmp.cpp = tx->img.cpp;
302 tx->tmp.w = tx->nblocksx;
303 tx->tmp.h = tx->nblocksy;
304 tx->tmp.d = 1;
305 tx->tmp.x0 = 0;
306 tx->tmp.y0 = 0;
307 tx->tmp.x1 = tx->tmp.w;
308 tx->tmp.y1 = tx->tmp.h;
309 tx->tmp.z = 0;
310
311 if (usage & PIPE_TRANSFER_READ)
312 nv30_transfer_rect(nv30, NEAREST, &tx->img, &tx->tmp);
313
314 if (tx->tmp.bo->map) {
315 *ptransfer = &tx->base;
316 return tx->tmp.bo->map;
317 }
318
319 if (usage & PIPE_TRANSFER_READ)
320 access |= NOUVEAU_BO_RD;
321 if (usage & PIPE_TRANSFER_WRITE)
322 access |= NOUVEAU_BO_WR;
323
324 ret = nouveau_bo_map(tx->tmp.bo, access, nv30->base.client);
325 if (ret) {
326 pipe_resource_reference(&tx->base.resource, NULL);
327 FREE(tx);
328 return NULL;
329 }
330
331 *ptransfer = &tx->base;
332 return tx->tmp.bo->map;
333 }
334
335 static void
nv30_miptree_transfer_unmap(struct pipe_context * pipe,struct pipe_transfer * ptx)336 nv30_miptree_transfer_unmap(struct pipe_context *pipe,
337 struct pipe_transfer *ptx)
338 {
339 struct nv30_context *nv30 = nv30_context(pipe);
340 struct nv30_transfer *tx = nv30_transfer(ptx);
341
342 if (ptx->usage & PIPE_TRANSFER_WRITE) {
343 nv30_transfer_rect(nv30, NEAREST, &tx->tmp, &tx->img);
344
345 /* Allow the copies above to finish executing before freeing the source */
346 nouveau_fence_work(nv30->screen->base.fence.current,
347 nouveau_fence_unref_bo, tx->tmp.bo);
348 } else {
349 nouveau_bo_ref(NULL, &tx->tmp.bo);
350 }
351 pipe_resource_reference(&ptx->resource, NULL);
352 FREE(tx);
353 }
354
355 const struct u_resource_vtbl nv30_miptree_vtbl = {
356 nv30_miptree_get_handle,
357 nv30_miptree_destroy,
358 nv30_miptree_transfer_map,
359 u_default_transfer_flush_region,
360 nv30_miptree_transfer_unmap,
361 };
362
363 struct pipe_resource *
nv30_miptree_create(struct pipe_screen * pscreen,const struct pipe_resource * tmpl)364 nv30_miptree_create(struct pipe_screen *pscreen,
365 const struct pipe_resource *tmpl)
366 {
367 struct nouveau_device *dev = nouveau_screen(pscreen)->device;
368 struct nv30_miptree *mt = CALLOC_STRUCT(nv30_miptree);
369 struct pipe_resource *pt = &mt->base.base;
370 unsigned blocksz, size;
371 unsigned w, h, d, l;
372 int ret;
373
374 switch (tmpl->nr_samples) {
375 case 4:
376 mt->ms_mode = 0x00004000;
377 mt->ms_x = 1;
378 mt->ms_y = 1;
379 break;
380 case 2:
381 mt->ms_mode = 0x00003000;
382 mt->ms_x = 1;
383 mt->ms_y = 0;
384 break;
385 default:
386 mt->ms_mode = 0x00000000;
387 mt->ms_x = 0;
388 mt->ms_y = 0;
389 break;
390 }
391
392 mt->base.vtbl = &nv30_miptree_vtbl;
393 *pt = *tmpl;
394 pipe_reference_init(&pt->reference, 1);
395 pt->screen = pscreen;
396
397 w = pt->width0 << mt->ms_x;
398 h = pt->height0 << mt->ms_y;
399 d = (pt->target == PIPE_TEXTURE_3D) ? pt->depth0 : 1;
400 blocksz = util_format_get_blocksize(pt->format);
401
402 if ((pt->target == PIPE_TEXTURE_RECT) ||
403 (pt->bind & PIPE_BIND_SCANOUT) ||
404 !util_is_power_of_two(pt->width0) ||
405 !util_is_power_of_two(pt->height0) ||
406 !util_is_power_of_two(pt->depth0) ||
407 util_format_is_compressed(pt->format) ||
408 util_format_is_float(pt->format) || mt->ms_mode) {
409 mt->uniform_pitch = util_format_get_nblocksx(pt->format, w) * blocksz;
410 mt->uniform_pitch = align(mt->uniform_pitch, 64);
411 if (pt->bind & PIPE_BIND_SCANOUT) {
412 struct nv30_screen *screen = nv30_screen(pscreen);
413 int pitch_align = MAX2(
414 screen->eng3d->oclass >= NV40_3D_CLASS ? 1024 : 256,
415 /* round_down_pow2(mt->uniform_pitch / 4) */
416 1 << (util_last_bit(mt->uniform_pitch / 4) - 1));
417 mt->uniform_pitch = align(mt->uniform_pitch, pitch_align);
418 }
419 }
420
421 if (!mt->uniform_pitch)
422 mt->swizzled = true;
423
424 size = 0;
425 for (l = 0; l <= pt->last_level; l++) {
426 struct nv30_miptree_level *lvl = &mt->level[l];
427 unsigned nbx = util_format_get_nblocksx(pt->format, w);
428 unsigned nby = util_format_get_nblocksx(pt->format, h);
429
430 lvl->offset = size;
431 lvl->pitch = mt->uniform_pitch;
432 if (!lvl->pitch)
433 lvl->pitch = nbx * blocksz;
434
435 lvl->zslice_size = lvl->pitch * nby;
436 size += lvl->zslice_size * d;
437
438 w = u_minify(w, 1);
439 h = u_minify(h, 1);
440 d = u_minify(d, 1);
441 }
442
443 mt->layer_size = size;
444 if (pt->target == PIPE_TEXTURE_CUBE) {
445 if (!mt->uniform_pitch)
446 mt->layer_size = align(mt->layer_size, 128);
447 size = mt->layer_size * 6;
448 }
449
450 ret = nouveau_bo_new(dev, NOUVEAU_BO_VRAM, 256, size, NULL, &mt->base.bo);
451 if (ret) {
452 FREE(mt);
453 return NULL;
454 }
455
456 mt->base.domain = NOUVEAU_BO_VRAM;
457 return &mt->base.base;
458 }
459
460 struct pipe_resource *
nv30_miptree_from_handle(struct pipe_screen * pscreen,const struct pipe_resource * tmpl,struct winsys_handle * handle)461 nv30_miptree_from_handle(struct pipe_screen *pscreen,
462 const struct pipe_resource *tmpl,
463 struct winsys_handle *handle)
464 {
465 struct nv30_miptree *mt;
466 unsigned stride;
467
468 /* only supports 2D, non-mipmapped textures for the moment */
469 if ((tmpl->target != PIPE_TEXTURE_2D &&
470 tmpl->target != PIPE_TEXTURE_RECT) ||
471 tmpl->last_level != 0 ||
472 tmpl->depth0 != 1 ||
473 tmpl->array_size > 1)
474 return NULL;
475
476 mt = CALLOC_STRUCT(nv30_miptree);
477 if (!mt)
478 return NULL;
479
480 mt->base.bo = nouveau_screen_bo_from_handle(pscreen, handle, &stride);
481 if (mt->base.bo == NULL) {
482 FREE(mt);
483 return NULL;
484 }
485
486 mt->base.base = *tmpl;
487 mt->base.vtbl = &nv30_miptree_vtbl;
488 pipe_reference_init(&mt->base.base.reference, 1);
489 mt->base.base.screen = pscreen;
490 mt->uniform_pitch = stride;
491 mt->level[0].pitch = mt->uniform_pitch;
492 mt->level[0].offset = 0;
493
494 /* no need to adjust bo reference count */
495 return &mt->base.base;
496 }
497
498 struct pipe_surface *
nv30_miptree_surface_new(struct pipe_context * pipe,struct pipe_resource * pt,const struct pipe_surface * tmpl)499 nv30_miptree_surface_new(struct pipe_context *pipe,
500 struct pipe_resource *pt,
501 const struct pipe_surface *tmpl)
502 {
503 struct nv30_miptree *mt = nv30_miptree(pt); /* guaranteed */
504 struct nv30_surface *ns;
505 struct pipe_surface *ps;
506 struct nv30_miptree_level *lvl = &mt->level[tmpl->u.tex.level];
507
508 ns = CALLOC_STRUCT(nv30_surface);
509 if (!ns)
510 return NULL;
511 ps = &ns->base;
512
513 pipe_reference_init(&ps->reference, 1);
514 pipe_resource_reference(&ps->texture, pt);
515 ps->context = pipe;
516 ps->format = tmpl->format;
517 ps->u.tex.level = tmpl->u.tex.level;
518 ps->u.tex.first_layer = tmpl->u.tex.first_layer;
519 ps->u.tex.last_layer = tmpl->u.tex.last_layer;
520
521 ns->width = u_minify(pt->width0, ps->u.tex.level);
522 ns->height = u_minify(pt->height0, ps->u.tex.level);
523 ns->depth = ps->u.tex.last_layer - ps->u.tex.first_layer + 1;
524 ns->offset = layer_offset(pt, ps->u.tex.level, ps->u.tex.first_layer);
525 if (mt->swizzled)
526 ns->pitch = 4096; /* random, just something the hw won't reject.. */
527 else
528 ns->pitch = lvl->pitch;
529
530 /* comment says there are going to be removed, but they're used by the st */
531 ps->width = ns->width;
532 ps->height = ns->height;
533 return ps;
534 }
535
536 void
nv30_miptree_surface_del(struct pipe_context * pipe,struct pipe_surface * ps)537 nv30_miptree_surface_del(struct pipe_context *pipe, struct pipe_surface *ps)
538 {
539 struct nv30_surface *ns = nv30_surface(ps);
540
541 pipe_resource_reference(&ps->texture, NULL);
542 FREE(ns);
543 }
544