projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge commit 'origin/7.8'
[mesa.git] / src / gallium / drivers / nv50 / nv50_transfer.c
1
2 #include "pipe/p_context.h"
3 #include "util/u_inlines.h"
4 #include "util/u_format.h"
5 #include "util/u_math.h"
6
7 #include "nv50_context.h"
8 #include "nv50_transfer.h"
9 #include "nv50_resource.h"
10
11 struct nv50_transfer {
12 struct pipe_transfer base;
13 struct nouveau_bo *bo;
14 int map_refcnt;
15 unsigned level_offset;
16 unsigned level_tiling;
17 int level_pitch;
18 int level_width;
19 int level_height;
20 int level_depth;
21 int level_x;
22 int level_y;
23 int level_z;
24 unsigned nblocksx;
25 unsigned nblocksy;
26 };
27
28 static void
29 nv50_transfer_rect_m2mf(struct pipe_screen *pscreen,
30 struct nouveau_bo *src_bo, unsigned src_offset,
31 int src_pitch, unsigned src_tile_mode,
32 int sx, int sy, int sz, int sw, int sh, int sd,
33 struct nouveau_bo *dst_bo, unsigned dst_offset,
34 int dst_pitch, unsigned dst_tile_mode,
35 int dx, int dy, int dz, int dw, int dh, int dd,
36 int cpp, int width, int height,
37 unsigned src_reloc, unsigned dst_reloc)
38 {
39 struct nv50_screen *screen = nv50_screen(pscreen);
40 struct nouveau_channel *chan = screen->m2mf->channel;
41 struct nouveau_grobj *m2mf = screen->m2mf;
42
43 src_reloc |= NOUVEAU_BO_RD;
44 dst_reloc |= NOUVEAU_BO_WR;
45
46 WAIT_RING (chan, 14);
47
48 if (!src_bo->tile_flags) {
49 BEGIN_RING(chan, m2mf,
50 NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_IN, 1);
51 OUT_RING (chan, 1);
52 BEGIN_RING(chan, m2mf,
53 NV04_MEMORY_TO_MEMORY_FORMAT_PITCH_IN, 1);
54 OUT_RING (chan, src_pitch);
55 src_offset += (sy * src_pitch) + (sx * cpp);
56 } else {
57 BEGIN_RING(chan, m2mf,
58 NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_IN, 6);
59 OUT_RING (chan, 0);
60 OUT_RING (chan, src_tile_mode << 4);
61 OUT_RING (chan, sw * cpp);
62 OUT_RING (chan, sh);
63 OUT_RING (chan, sd);
64 OUT_RING (chan, sz); /* copying only 1 zslice per call */
65 }
66
67 if (!dst_bo->tile_flags) {
68 BEGIN_RING(chan, m2mf,
69 NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_OUT, 1);
70 OUT_RING (chan, 1);
71 BEGIN_RING(chan, m2mf,
72 NV04_MEMORY_TO_MEMORY_FORMAT_PITCH_OUT, 1);
73 OUT_RING (chan, dst_pitch);
74 dst_offset += (dy * dst_pitch) + (dx * cpp);
75 } else {
76 BEGIN_RING(chan, m2mf,
77 NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_OUT, 6);
78 OUT_RING (chan, 0);
79 OUT_RING (chan, dst_tile_mode << 4);
80 OUT_RING (chan, dw * cpp);
81 OUT_RING (chan, dh);
82 OUT_RING (chan, dd);
83 OUT_RING (chan, dz); /* copying only 1 zslice per call */
84 }
85
86 while (height) {
87 int line_count = height > 2047 ? 2047 : height;
88
89 MARK_RING (chan, 15, 4); /* flush on lack of space or relocs */
90 BEGIN_RING(chan, m2mf,
91 NV50_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN_HIGH, 2);
92 OUT_RELOCh(chan, src_bo, src_offset, src_reloc);
93 OUT_RELOCh(chan, dst_bo, dst_offset, dst_reloc);
94 BEGIN_RING(chan, m2mf,
95 NV04_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 2);
96 OUT_RELOCl(chan, src_bo, src_offset, src_reloc);
97 OUT_RELOCl(chan, dst_bo, dst_offset, dst_reloc);
98 if (src_bo->tile_flags) {
99 BEGIN_RING(chan, m2mf,
100 NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN, 1);
101 OUT_RING (chan, (sy << 16) | (sx * cpp));
102 } else {
103 src_offset += (line_count * src_pitch);
104 }
105 if (dst_bo->tile_flags) {
106 BEGIN_RING(chan, m2mf,
107 NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT, 1);
108 OUT_RING (chan, (dy << 16) | (dx * cpp));
109 } else {
110 dst_offset += (line_count * dst_pitch);
111 }
112 BEGIN_RING(chan, m2mf,
113 NV04_MEMORY_TO_MEMORY_FORMAT_LINE_LENGTH_IN, 4);
114 OUT_RING (chan, width * cpp);
115 OUT_RING (chan, line_count);
116 OUT_RING (chan, 0x00000101);
117 OUT_RING (chan, 0);
118 FIRE_RING (chan);
119
120 height -= line_count;
121 sy += line_count;
122 dy += line_count;
123 }
124 }
125
126 struct pipe_transfer *
127 nv50_miptree_transfer_new(struct pipe_context *pcontext,
128 struct pipe_resource *pt,
129 struct pipe_subresource sr,
130 unsigned usage,
131 const struct pipe_box *box)
132 {
133 struct pipe_screen *pscreen = pcontext->screen;
134 struct nouveau_device *dev = nouveau_screen(pscreen)->device;
135 struct nv50_miptree *mt = nv50_miptree(pt);
136 struct nv50_miptree_level *lvl = &mt->level[sr.level];
137 struct nv50_transfer *tx;
138 unsigned nx, ny, image = 0;
139 int ret;
140
141 if (pt->target == PIPE_TEXTURE_CUBE)
142 image = sr.face;
143
144 tx = CALLOC_STRUCT(nv50_transfer);
145 if (!tx)
146 return NULL;
147
148 /* Don't handle 3D transfers yet.
149 */
150 assert(box->depth == 1);
151
152
153 pipe_resource_reference(&tx->base.resource, pt);
154 tx->base.sr = sr;
155 tx->base.usage = usage;
156 tx->base.box = *box;
157 tx->nblocksx = util_format_get_nblocksx(pt->format, u_minify(pt->width0, sr.level));
158 tx->nblocksy = util_format_get_nblocksy(pt->format, u_minify(pt->height0, sr.level));
159 tx->base.stride = tx->nblocksx * util_format_get_blocksize(pt->format);
160 tx->base.usage = usage;
161
162 tx->level_pitch = lvl->pitch;
163 tx->level_width = u_minify(mt->base.base.width0, sr.level);
164 tx->level_height = u_minify(mt->base.base.height0, sr.level);
165 tx->level_depth = u_minify(mt->base.base.depth0, sr.level);
166 tx->level_offset = lvl->image_offset[image];
167 tx->level_tiling = lvl->tile_mode;
168 tx->level_z = box->z;
169 tx->level_x = util_format_get_nblocksx(pt->format, box->x);
170 tx->level_y = util_format_get_nblocksy(pt->format, box->y);
171 ret = nouveau_bo_new(dev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0,
172 tx->nblocksy * tx->base.stride, &tx->bo);
173 if (ret) {
174 FREE(tx);
175 return NULL;
176 }
177
178 if (usage & PIPE_TRANSFER_READ) {
179 nx = util_format_get_nblocksx(pt->format, box->width);
180 ny = util_format_get_nblocksy(pt->format, box->height);
181
182 nv50_transfer_rect_m2mf(pscreen, mt->base.bo, tx->level_offset,
183 tx->level_pitch, tx->level_tiling,
184 box->x, box->y, box->z,
185 tx->nblocksx, tx->nblocksy,
186 tx->level_depth,
187 tx->bo, 0,
188 tx->base.stride, tx->bo->tile_mode,
189 0, 0, 0,
190 tx->nblocksx, tx->nblocksy, 1,
191 util_format_get_blocksize(pt->format), nx, ny,
192 NOUVEAU_BO_VRAM | NOUVEAU_BO_GART,
193 NOUVEAU_BO_GART);
194 }
195
196 return &tx->base;
197 }
198
199 void
200 nv50_miptree_transfer_del(struct pipe_context *pcontext,
201 struct pipe_transfer *ptx)
202 {
203 struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
204 struct nv50_miptree *mt = nv50_miptree(ptx->resource);
205 struct pipe_resource *pt = ptx->resource;
206
207 unsigned nx = util_format_get_nblocksx(pt->format, tx->base.box.width);
208 unsigned ny = util_format_get_nblocksy(pt->format, tx->base.box.height);
209
210 if (ptx->usage & PIPE_TRANSFER_WRITE) {
211 struct pipe_screen *pscreen = pcontext->screen;
212
213 nv50_transfer_rect_m2mf(pscreen, tx->bo, 0,
214 tx->base.stride, tx->bo->tile_mode,
215 0, 0, 0,
216 tx->nblocksx, tx->nblocksy, 1,
217 mt->base.bo, tx->level_offset,
218 tx->level_pitch, tx->level_tiling,
219 tx->level_x, tx->level_y, tx->level_z,
220 tx->nblocksx, tx->nblocksy,
221 tx->level_depth,
222 util_format_get_blocksize(pt->format), nx, ny,
223 NOUVEAU_BO_GART, NOUVEAU_BO_VRAM |
224 NOUVEAU_BO_GART);
225 }
226
227 nouveau_bo_ref(NULL, &tx->bo);
228 pipe_resource_reference(&ptx->resource, NULL);
229 FREE(ptx);
230 }
231
232 void *
233 nv50_miptree_transfer_map(struct pipe_context *pcontext,
234 struct pipe_transfer *ptx)
235 {
236 struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
237 unsigned flags = 0;
238 int ret;
239
240 if (tx->map_refcnt++)
241 return tx->bo->map;
242
243 if (ptx->usage & PIPE_TRANSFER_WRITE)
244 flags |= NOUVEAU_BO_WR;
245 if (ptx->usage & PIPE_TRANSFER_READ)
246 flags |= NOUVEAU_BO_RD;
247
248 ret = nouveau_bo_map(tx->bo, flags);
249 if (ret) {
250 tx->map_refcnt = 0;
251 return NULL;
252 }
253 return tx->bo->map;
254 }
255
256 void
257 nv50_miptree_transfer_unmap(struct pipe_context *pcontext,
258 struct pipe_transfer *ptx)
259 {
260 struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
261
262 if (--tx->map_refcnt)
263 return;
264 nouveau_bo_unmap(tx->bo);
265 }
266
267
268 void
269 nv50_upload_sifc(struct nv50_context *nv50,
270 struct nouveau_bo *bo, unsigned dst_offset, unsigned reloc,
271 unsigned dst_format, int dst_w, int dst_h, int dst_pitch,
272 void *src, unsigned src_format, int src_pitch,
273 int x, int y, int w, int h, int cpp)
274 {
275 struct nouveau_channel *chan = nv50->screen->base.channel;
276 struct nouveau_grobj *eng2d = nv50->screen->eng2d;
277 struct nouveau_grobj *tesla = nv50->screen->tesla;
278 unsigned line_dwords = (w * cpp + 3) / 4;
279
280 reloc |= NOUVEAU_BO_WR;
281
282 MARK_RING (chan, 32, 2); /* flush on lack of space or relocs */
283
284 if (bo->tile_flags) {
285 BEGIN_RING(chan, eng2d, NV50_2D_DST_FORMAT, 5);
286 OUT_RING (chan, dst_format);
287 OUT_RING (chan, 0);
288 OUT_RING (chan, bo->tile_mode << 4);
289 OUT_RING (chan, 1);
290 OUT_RING (chan, 0);
291 } else {
292 BEGIN_RING(chan, eng2d, NV50_2D_DST_FORMAT, 2);
293 OUT_RING (chan, dst_format);
294 OUT_RING (chan, 1);
295 BEGIN_RING(chan, eng2d, NV50_2D_DST_PITCH, 1);
296 OUT_RING (chan, dst_pitch);
297 }
298
299 BEGIN_RING(chan, eng2d, NV50_2D_DST_WIDTH, 4);
300 OUT_RING (chan, dst_w);
301 OUT_RING (chan, dst_h);
302 OUT_RELOCh(chan, bo, dst_offset, reloc);
303 OUT_RELOCl(chan, bo, dst_offset, reloc);
304
305 /* NV50_2D_OPERATION_SRCCOPY assumed already set */
306
307 BEGIN_RING(chan, eng2d, NV50_2D_SIFC_BITMAP_ENABLE, 2);
308 OUT_RING (chan, 0);
309 OUT_RING (chan, src_format);
310 BEGIN_RING(chan, eng2d, NV50_2D_SIFC_WIDTH, 10);
311 OUT_RING (chan, w);
312 OUT_RING (chan, h);
313 OUT_RING (chan, 0);
314 OUT_RING (chan, 1);
315 OUT_RING (chan, 0);
316 OUT_RING (chan, 1);
317 OUT_RING (chan, 0);
318 OUT_RING (chan, x);
319 OUT_RING (chan, 0);
320 OUT_RING (chan, y);
321
322 while (h--) {
323 const uint32_t *p = src;
324 unsigned count = line_dwords;
325
326 while (count) {
327 unsigned nr = MIN2(count, 1792);
328
329 if (AVAIL_RING(chan) <= nr) {
330 FIRE_RING (chan);
331
332 BEGIN_RING(chan, eng2d,
333 NV50_2D_DST_ADDRESS_HIGH, 2);
334 OUT_RELOCh(chan, bo, dst_offset, reloc);
335 OUT_RELOCl(chan, bo, dst_offset, reloc);
336 }
337 assert(AVAIL_RING(chan) > nr);
338
339 BEGIN_RING(chan, eng2d,
340 NV50_2D_SIFC_DATA | (2 << 29), nr);
341 OUT_RINGp (chan, p, nr);
342
343 p += nr;
344 count -= nr;
345 }
346
347 src += src_pitch;
348 }
349
350 BEGIN_RING(chan, tesla, NV50TCL_CODE_CB_FLUSH, 1);
351 OUT_RING (chan, 0);
352 }