?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert between 56095 -> 55830 in arch
[AROS.git] / workbench / libs / mesa / src / gallium / drivers / nv50 / nv50_transfer.c
blobd9fb22aa673a0c9601de1ba5ddd1059997084acb
1
2 #include "util/u_format.h"
3
4 #include "nv50_context.h"
5 #include "nv50_transfer.h"
6
7 #include "nv50_defs.xml.h"
8
9 struct nv50_transfer {
10 struct pipe_transfer base;
11 struct nv50_m2mf_rect rect[2];
12 uint32_t nblocksx;
13 uint32_t nblocksy;
14 };
15
16 static void
17 nv50_m2mf_transfer_rect(struct pipe_screen *pscreen,
18 const struct nv50_m2mf_rect *dst,
19 const struct nv50_m2mf_rect *src,
20 uint32_t nblocksx, uint32_t nblocksy)
21 {
22 struct nouveau_channel *chan = nouveau_screen(pscreen)->channel;
23 const int cpp = dst->cpp;
24 uint32_t src_ofst = src->base;
25 uint32_t dst_ofst = dst->base;
26 uint32_t height = nblocksy;
27 uint32_t sy = src->y;
28 uint32_t dy = dst->y;
29
30 assert(dst->cpp == src->cpp);
31
32 if (nouveau_bo_tile_layout(src->bo)) {
33 BEGIN_RING(chan, RING_MF(LINEAR_IN), 6);
34 OUT_RING (chan, 0);
35 OUT_RING (chan, src->tile_mode << 4);
36 OUT_RING (chan, src->width * cpp);
37 OUT_RING (chan, src->height);
38 OUT_RING (chan, src->depth);
39 OUT_RING (chan, src->z);
40 } else {
41 src_ofst += src->y * src->pitch + src->x * cpp;
42
43 BEGIN_RING(chan, RING_MF(LINEAR_IN), 1);
44 OUT_RING (chan, 1);
45 BEGIN_RING(chan, RING_MF_(NV04_M2MF_PITCH_IN), 1);
46 OUT_RING (chan, src->pitch);
47 }
48
49 if (nouveau_bo_tile_layout(dst->bo)) {
50 BEGIN_RING(chan, RING_MF(LINEAR_OUT), 6);
51 OUT_RING (chan, 0);
52 OUT_RING (chan, dst->tile_mode << 4);
53 OUT_RING (chan, dst->width * cpp);
54 OUT_RING (chan, dst->height);
55 OUT_RING (chan, dst->depth);
56 OUT_RING (chan, dst->z);
57 } else {
58 dst_ofst += dst->y * dst->pitch + dst->x * cpp;
59
60 BEGIN_RING(chan, RING_MF(LINEAR_OUT), 1);
61 OUT_RING (chan, 1);
62 BEGIN_RING(chan, RING_MF_(NV04_M2MF_PITCH_OUT), 1);
63 OUT_RING (chan, dst->pitch);
64 }
65
66 while (height) {
67 int line_count = height > 2047 ? 2047 : height;
68
69 MARK_RING (chan, 17, 4);
70
71 BEGIN_RING(chan, RING_MF(OFFSET_IN_HIGH), 2);
72 OUT_RELOCh(chan, src->bo, src_ofst, src->domain | NOUVEAU_BO_RD);
73 OUT_RELOCh(chan, dst->bo, dst_ofst, dst->domain | NOUVEAU_BO_WR);
74
75 BEGIN_RING(chan, RING_MF_(NV04_M2MF_OFFSET_IN), 2);
76 OUT_RELOCl(chan, src->bo, src_ofst, src->domain | NOUVEAU_BO_RD);
77 OUT_RELOCl(chan, dst->bo, dst_ofst, dst->domain | NOUVEAU_BO_WR);
78
79 if (nouveau_bo_tile_layout(src->bo)) {
80 BEGIN_RING(chan, RING_MF(TILING_POSITION_IN), 1);
81 OUT_RING (chan, (sy << 16) | (src->x * cpp));
82 } else {
83 src_ofst += line_count * src->pitch;
84 }
85 if (nouveau_bo_tile_layout(dst->bo)) {
86 BEGIN_RING(chan, RING_MF(TILING_POSITION_OUT), 1);
87 OUT_RING (chan, (dy << 16) | (dst->x * cpp));
88 } else {
89 dst_ofst += line_count * dst->pitch;
90 }
91
92 BEGIN_RING(chan, RING_MF_(NV04_M2MF_LINE_LENGTH_IN), 4);
93 OUT_RING (chan, nblocksx * cpp);
94 OUT_RING (chan, line_count);
95 OUT_RING (chan, (1 << 8) | (1 << 0));
96 OUT_RING (chan, 0);
97
98 height -= line_count;
99 sy += line_count;
100 dy += line_count;
101 }
102 }
103
104 void
105 nv50_sifc_linear_u8(struct nouveau_context *nv,
106 struct nouveau_bo *dst, unsigned offset, unsigned domain,
107 unsigned size, void *data)
108 {
109 struct nouveau_channel *chan = nv->screen->channel;
110 uint32_t *src = (uint32_t *)data;
111 unsigned count = (size + 3) / 4;
112 unsigned xcoord = offset & 0xff;
113
114 offset &= ~0xff;
115
116 MARK_RING (chan, 23, 4);
117 BEGIN_RING(chan, RING_2D(DST_FORMAT), 2);
118 OUT_RING (chan, NV50_SURFACE_FORMAT_R8_UNORM);
119 OUT_RING (chan, 1);
120 BEGIN_RING(chan, RING_2D(DST_PITCH), 5);
121 OUT_RING (chan, 262144);
122 OUT_RING (chan, 65536);
123 OUT_RING (chan, 1);
124 OUT_RELOCh(chan, dst, offset, domain | NOUVEAU_BO_WR);
125 OUT_RELOCl(chan, dst, offset, domain | NOUVEAU_BO_WR);
126 BEGIN_RING(chan, RING_2D(SIFC_BITMAP_ENABLE), 2);
127 OUT_RING (chan, 0);
128 OUT_RING (chan, NV50_SURFACE_FORMAT_R8_UNORM);
129 BEGIN_RING(chan, RING_2D(SIFC_WIDTH), 10);
130 OUT_RING (chan, size);
131 OUT_RING (chan, 1);
132 OUT_RING (chan, 0);
133 OUT_RING (chan, 1);
134 OUT_RING (chan, 0);
135 OUT_RING (chan, 1);
136 OUT_RING (chan, 0);
137 OUT_RING (chan, xcoord);
138 OUT_RING (chan, 0);
139 OUT_RING (chan, 0);
140
141 while (count) {
142 unsigned nr = AVAIL_RING(chan);
143
144 if (nr < 9) {
145 FIRE_RING(chan);
146 nouveau_bo_validate(chan, dst, NOUVEAU_BO_WR);
147 continue;
148 }
149 nr = MIN2(count, nr - 1);
150 nr = MIN2(nr, NV04_PFIFO_MAX_PACKET_LEN);
151
152 BEGIN_RING_NI(chan, RING_2D(SIFC_DATA), nr);
153 OUT_RINGp (chan, src, nr);
154
155 src += nr;
156 count -= nr;
157 }
158 }
159
160 void
161 nv50_m2mf_copy_linear(struct nouveau_context *nv,
162 struct nouveau_bo *dst, unsigned dstoff, unsigned dstdom,
163 struct nouveau_bo *src, unsigned srcoff, unsigned srcdom,
164 unsigned size)
165 {
166 struct nouveau_channel *chan = nv->screen->channel;
167
168 BEGIN_RING(chan, RING_MF(LINEAR_IN), 1);
169 OUT_RING (chan, 1);
170 BEGIN_RING(chan, RING_MF(LINEAR_OUT), 1);
171 OUT_RING (chan, 1);
172
173 while (size) {
174 unsigned bytes = MIN2(size, 1 << 17);
175
176 MARK_RING (chan, 11, 4);
177 BEGIN_RING(chan, RING_MF(OFFSET_IN_HIGH), 2);
178 OUT_RELOCh(chan, src, srcoff, srcdom | NOUVEAU_BO_RD);
179 OUT_RELOCh(chan, dst, dstoff, dstdom | NOUVEAU_BO_WR);
180 BEGIN_RING(chan, RING_MF_(NV04_M2MF_OFFSET_IN), 2);
181 OUT_RELOCl(chan, src, srcoff, srcdom | NOUVEAU_BO_RD);
182 OUT_RELOCl(chan, dst, dstoff, dstdom | NOUVEAU_BO_WR);
183 BEGIN_RING(chan, RING_MF_(NV04_M2MF_LINE_LENGTH_IN), 4);
184 OUT_RING (chan, bytes);
185 OUT_RING (chan, 1);
186 OUT_RING (chan, (1 << 8) | (1 << 0));
187 OUT_RING (chan, 0);
188
189 srcoff += bytes;
190 dstoff += bytes;
191 size -= bytes;
192 }
193 }
194
195 struct pipe_transfer *
196 nv50_miptree_transfer_new(struct pipe_context *pctx,
197 struct pipe_resource *res,
198 unsigned level,
199 unsigned usage,
200 const struct pipe_box *box)
201 {
202 struct nv50_context *nv50 = nv50_context(pctx);
203 struct pipe_screen *pscreen = pctx->screen;
204 struct nouveau_device *dev = nv50->screen->base.device;
205 struct nv50_miptree *mt = nv50_miptree(res);
206 struct nv50_miptree_level *lvl = &mt->level[level];
207 struct nv50_transfer *tx;
208 uint32_t size;
209 uint32_t w, h, d, z, layer;
210 int ret;
211
212 if (usage & PIPE_TRANSFER_MAP_DIRECTLY)
213 return NULL;
214
215 if (mt->layout_3d) {
216 z = box->z;
217 d = u_minify(res->depth0, level);
218 layer = 0;
219 } else {
220 z = 0;
221 d = 1;
222 layer = box->z;
223 }
224
225 tx = CALLOC_STRUCT(nv50_transfer);
226 if (!tx)
227 return NULL;
228
229 pipe_resource_reference(&tx->base.resource, res);
230
231 tx->base.level = level;
232 tx->base.usage = usage;
233 tx->base.box = *box;
234
235 tx->nblocksx = util_format_get_nblocksx(res->format, box->width);
236 tx->nblocksy = util_format_get_nblocksy(res->format, box->height);
237
238 tx->base.stride = tx->nblocksx * util_format_get_blocksize(res->format);
239 tx->base.layer_stride = tx->nblocksy * tx->base.stride;
240
241 w = u_minify(res->width0, level);
242 h = u_minify(res->height0, level);
243
244 tx->rect[0].cpp = tx->rect[1].cpp = util_format_get_blocksize(res->format);
245
246 tx->rect[0].bo = mt->base.bo;
247 tx->rect[0].base = lvl->offset + layer * mt->layer_stride;
248 tx->rect[0].tile_mode = lvl->tile_mode;
249 tx->rect[0].x = util_format_get_nblocksx(res->format, box->x);
250 tx->rect[0].y = util_format_get_nblocksy(res->format, box->y);
251 tx->rect[0].z = z;
252 tx->rect[0].width = util_format_get_nblocksx(res->format, w);
253 tx->rect[0].height = util_format_get_nblocksy(res->format, h);
254 tx->rect[0].depth = d;
255 tx->rect[0].pitch = lvl->pitch;
256 tx->rect[0].domain = NOUVEAU_BO_VRAM;
257
258 size = tx->base.layer_stride;
259
260 ret = nouveau_bo_new(dev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0,
261 size * tx->base.box.depth, &tx->rect[1].bo);
262 if (ret) {
263 FREE(tx);
264 return NULL;
265 }
266
267 tx->rect[1].width = tx->nblocksx;
268 tx->rect[1].height = tx->nblocksy;
269 tx->rect[1].depth = 1;
270 tx->rect[1].pitch = tx->base.stride;
271 tx->rect[1].domain = NOUVEAU_BO_GART;
272
273 if (usage & PIPE_TRANSFER_READ) {
274 unsigned base = tx->rect[0].base;
275 unsigned i;
276 for (i = 0; i < box->depth; ++i) {
277 nv50_m2mf_transfer_rect(pscreen, &tx->rect[1], &tx->rect[0],
278 tx->nblocksx, tx->nblocksy);
279 if (mt->layout_3d)
280 tx->rect[0].z++;
281 else
282 tx->rect[0].base += mt->layer_stride;
283 tx->rect[1].base += size;
284 }
285 tx->rect[0].z = z;
286 tx->rect[0].base = base;
287 tx->rect[1].base = 0;
288 }
289
290 return &tx->base;
291 }
292
293 void
294 nv50_miptree_transfer_del(struct pipe_context *pctx,
295 struct pipe_transfer *transfer)
296 {
297 struct pipe_screen *pscreen = pctx->screen;
298 struct nv50_transfer *tx = (struct nv50_transfer *)transfer;
299 struct nv50_miptree *mt = nv50_miptree(tx->base.resource);
300 unsigned i;
301
302 if (tx->base.usage & PIPE_TRANSFER_WRITE) {
303 for (i = 0; i < tx->base.box.depth; ++i) {
304 nv50_m2mf_transfer_rect(pscreen, &tx->rect[0], &tx->rect[1],
305 tx->nblocksx, tx->nblocksy);
306 if (mt->layout_3d)
307 tx->rect[0].z++;
308 else
309 tx->rect[0].base += mt->layer_stride;
310 tx->rect[1].base += tx->nblocksy * tx->base.stride;
311 }
312 }
313
314 nouveau_bo_ref(NULL, &tx->rect[1].bo);
315 pipe_resource_reference(&transfer->resource, NULL);
316
317 FREE(tx);
318 }
319
320 void *
321 nv50_miptree_transfer_map(struct pipe_context *pctx,
322 struct pipe_transfer *transfer)
323 {
324 struct nv50_transfer *tx = (struct nv50_transfer *)transfer;
325 int ret;
326 unsigned flags = 0;
327
328 if (tx->rect[1].bo->map)
329 return tx->rect[1].bo->map;
330
331 if (transfer->usage & PIPE_TRANSFER_READ)
332 flags = NOUVEAU_BO_RD;
333 if (transfer->usage & PIPE_TRANSFER_WRITE)
334 flags |= NOUVEAU_BO_WR;
335
336 ret = nouveau_bo_map(tx->rect[1].bo, flags);
337 if (ret)
338 return NULL;
339 return tx->rect[1].bo->map;
340 }
341
342 void
343 nv50_miptree_transfer_unmap(struct pipe_context *pctx,
344 struct pipe_transfer *transfer)
345 {
346 struct nv50_transfer *tx = (struct nv50_transfer *)transfer;
347
348 nouveau_bo_unmap(tx->rect[1].bo);
349 }
350
Mirror of AROS' svn.