2 #include "util/u_format.h"
4 #include "nvc0_context.h"
5 #include "nvc0_transfer.h"
7 #include "nv50_defs.xml.h"
10 struct pipe_transfer base
;
11 struct nvc0_m2mf_rect rect
[2];
17 nvc0_m2mf_transfer_rect(struct pipe_screen
*pscreen
,
18 const struct nvc0_m2mf_rect
*dst
,
19 const struct nvc0_m2mf_rect
*src
,
20 uint32_t nblocksx
, uint32_t nblocksy
)
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
;
29 uint32_t exec
= (1 << 20);
31 assert(dst
->cpp
== src
->cpp
);
33 if (nouveau_bo_tile_layout(src
->bo
)) {
34 BEGIN_RING(chan
, RING_MF(TILING_MODE_IN
), 5);
35 OUT_RING (chan
, src
->tile_mode
);
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
);
41 src_ofst
+= src
->y
* src
->pitch
+ src
->x
* cpp
;
43 BEGIN_RING(chan
, RING_MF(PITCH_IN
), 1);
44 OUT_RING (chan
, src
->width
* cpp
);
46 exec
|= NVC0_M2MF_EXEC_LINEAR_IN
;
49 if (nouveau_bo_tile_layout(dst
->bo
)) {
50 BEGIN_RING(chan
, RING_MF(TILING_MODE_OUT
), 5);
51 OUT_RING (chan
, dst
->tile_mode
);
52 OUT_RING (chan
, dst
->width
* cpp
);
53 OUT_RING (chan
, dst
->height
);
54 OUT_RING (chan
, dst
->depth
);
55 OUT_RING (chan
, dst
->z
);
57 dst_ofst
+= dst
->y
* dst
->pitch
+ dst
->x
* cpp
;
59 BEGIN_RING(chan
, RING_MF(PITCH_OUT
), 1);
60 OUT_RING (chan
, dst
->width
* cpp
);
62 exec
|= NVC0_M2MF_EXEC_LINEAR_OUT
;
66 int line_count
= height
> 2047 ? 2047 : height
;
68 MARK_RING (chan
, 17, 4);
70 BEGIN_RING(chan
, RING_MF(OFFSET_IN_HIGH
), 2);
71 OUT_RELOCh(chan
, src
->bo
, src_ofst
, src
->domain
| NOUVEAU_BO_RD
);
72 OUT_RELOCl(chan
, src
->bo
, src_ofst
, src
->domain
| NOUVEAU_BO_RD
);
74 BEGIN_RING(chan
, RING_MF(OFFSET_OUT_HIGH
), 2);
75 OUT_RELOCh(chan
, dst
->bo
, dst_ofst
, dst
->domain
| NOUVEAU_BO_WR
);
76 OUT_RELOCl(chan
, dst
->bo
, dst_ofst
, dst
->domain
| NOUVEAU_BO_WR
);
78 if (!(exec
& NVC0_M2MF_EXEC_LINEAR_IN
)) {
79 BEGIN_RING(chan
, RING_MF(TILING_POSITION_IN_X
), 2);
80 OUT_RING (chan
, src
->x
* cpp
);
83 src_ofst
+= line_count
* src
->pitch
;
85 if (!(exec
& NVC0_M2MF_EXEC_LINEAR_OUT
)) {
86 BEGIN_RING(chan
, RING_MF(TILING_POSITION_OUT_X
), 2);
87 OUT_RING (chan
, dst
->x
* cpp
);
90 dst_ofst
+= line_count
* dst
->pitch
;
93 BEGIN_RING(chan
, RING_MF(LINE_LENGTH_IN
), 2);
94 OUT_RING (chan
, nblocksx
* cpp
);
95 OUT_RING (chan
, line_count
);
96 BEGIN_RING(chan
, RING_MF(EXEC
), 1);
97 OUT_RING (chan
, exec
);
106 nvc0_m2mf_push_linear(struct nvc0_context
*nvc0
,
107 struct nouveau_bo
*dst
, unsigned domain
, int offset
,
108 unsigned size
, void *data
)
110 struct nouveau_channel
*chan
= nvc0
->screen
->base
.channel
;
111 uint32_t *src
= (uint32_t *)data
;
112 unsigned count
= (size
+ 3) / 4;
114 MARK_RING (chan
, 8, 2);
116 BEGIN_RING(chan
, RING_MF(OFFSET_OUT_HIGH
), 2);
117 OUT_RELOCh(chan
, dst
, offset
, domain
| NOUVEAU_BO_WR
);
118 OUT_RELOCl(chan
, dst
, offset
, domain
| NOUVEAU_BO_WR
);
119 BEGIN_RING(chan
, RING_MF(LINE_LENGTH_IN
), 2);
120 OUT_RING (chan
, size
);
122 BEGIN_RING(chan
, RING_MF(EXEC
), 1);
123 OUT_RING (chan
, 0x100111);
126 unsigned nr
= AVAIL_RING(chan
);
130 nouveau_bo_validate(chan
, dst
, NOUVEAU_BO_WR
);
133 nr
= MIN2(count
, nr
- 1);
134 nr
= MIN2(nr
, NV04_PFIFO_MAX_PACKET_LEN
);
136 BEGIN_RING_NI(chan
, RING_MF(DATA
), nr
);
137 OUT_RINGp (chan
, src
, nr
);
145 nvc0_m2mf_copy_linear(struct nvc0_context
*nvc0
,
146 struct nouveau_bo
*dst
, unsigned dstoff
, unsigned dstdom
,
147 struct nouveau_bo
*src
, unsigned srcoff
, unsigned srcdom
,
150 struct nouveau_channel
*chan
= nvc0
->screen
->base
.channel
;
153 unsigned bytes
= MIN2(size
, 1 << 17);
155 MARK_RING (chan
, 11, 4);
157 BEGIN_RING(chan
, RING_MF(OFFSET_OUT_HIGH
), 2);
158 OUT_RELOCh(chan
, dst
, dstoff
, dstdom
| NOUVEAU_BO_WR
);
159 OUT_RELOCl(chan
, dst
, dstoff
, dstdom
| NOUVEAU_BO_WR
);
160 BEGIN_RING(chan
, RING_MF(OFFSET_IN_HIGH
), 2);
161 OUT_RELOCh(chan
, src
, srcoff
, srcdom
| NOUVEAU_BO_RD
);
162 OUT_RELOCl(chan
, src
, srcoff
, srcdom
| NOUVEAU_BO_RD
);
163 BEGIN_RING(chan
, RING_MF(LINE_LENGTH_IN
), 2);
164 OUT_RING (chan
, bytes
);
166 BEGIN_RING(chan
, RING_MF(EXEC
), 1);
167 OUT_RING (chan
, (1 << NVC0_M2MF_EXEC_INC__SHIFT
) |
168 NVC0_M2MF_EXEC_LINEAR_IN
| NVC0_M2MF_EXEC_LINEAR_OUT
);
177 nvc0_m2mf_push_rect(struct pipe_screen
*pscreen
,
178 const struct nvc0_m2mf_rect
*dst
,
180 unsigned nblocksx
, unsigned nblocksy
)
182 struct nouveau_channel
*chan
;
183 const uint8_t *src
= (const uint8_t *)data
;
184 const int cpp
= dst
->cpp
;
185 const int line_len
= nblocksx
* cpp
;
188 assert(nouveau_bo_tile_layout(dst
->bo
));
190 BEGIN_RING(chan
, RING_MF(TILING_MODE_OUT
), 5);
191 OUT_RING (chan
, dst
->tile_mode
);
192 OUT_RING (chan
, dst
->width
* cpp
);
193 OUT_RING (chan
, dst
->height
);
194 OUT_RING (chan
, dst
->depth
);
195 OUT_RING (chan
, dst
->z
);
198 int line_count
, words
;
199 int size
= MIN2(AVAIL_RING(chan
), NV04_PFIFO_MAX_PACKET_LEN
);
201 if (size
< (12 + words
)) {
205 line_count
= (size
* 4) / line_len
;
206 words
= (line_count
* line_len
+ 3) / 4;
208 BEGIN_RING(chan
, RING_MF(OFFSET_OUT_HIGH
), 2);
209 OUT_RELOCh(chan
, dst
->bo
, dst
->base
, dst
->domain
| NOUVEAU_BO_WR
);
210 OUT_RELOCl(chan
, dst
->bo
, dst
->base
, dst
->domain
| NOUVEAU_BO_WR
);
212 BEGIN_RING(chan
, RING_MF(TILING_POSITION_OUT_X
), 2);
213 OUT_RING (chan
, dst
->x
* cpp
);
215 BEGIN_RING(chan
, RING_MF(LINE_LENGTH_IN
), 2);
216 OUT_RING (chan
, line_len
);
217 OUT_RING (chan
, line_count
);
218 BEGIN_RING(chan
, RING_MF(EXEC
), 1);
219 OUT_RING (chan
, (1 << NVC0_M2MF_EXEC_INC__SHIFT
) |
220 NVC0_M2MF_EXEC_PUSH
| NVC0_M2MF_EXEC_LINEAR_IN
);
222 BEGIN_RING_NI(chan
, RING_MF(DATA
), words
);
223 OUT_RINGp (chan
, src
, words
);
226 src
+= line_len
* line_count
;
227 nblocksy
-= line_count
;
231 struct pipe_transfer
*
232 nvc0_miptree_transfer_new(struct pipe_context
*pctx
,
233 struct pipe_resource
*res
,
236 const struct pipe_box
*box
)
238 struct nvc0_context
*nvc0
= nvc0_context(pctx
);
239 struct pipe_screen
*pscreen
= pctx
->screen
;
240 struct nouveau_device
*dev
= nvc0
->screen
->base
.device
;
241 struct nvc0_miptree
*mt
= nvc0_miptree(res
);
242 struct nvc0_miptree_level
*lvl
= &mt
->level
[level
];
243 struct nvc0_transfer
*tx
;
245 uint32_t w
, h
, d
, z
, layer
;
250 d
= u_minify(res
->depth0
, level
);
258 tx
= CALLOC_STRUCT(nvc0_transfer
);
262 pipe_resource_reference(&tx
->base
.resource
, res
);
264 tx
->base
.level
= level
;
265 tx
->base
.usage
= usage
;
268 tx
->nblocksx
= util_format_get_nblocksx(res
->format
, box
->width
);
269 tx
->nblocksy
= util_format_get_nblocksy(res
->format
, box
->height
);
271 tx
->base
.stride
= tx
->nblocksx
* util_format_get_blocksize(res
->format
);
272 tx
->base
.layer_stride
= tx
->nblocksy
* tx
->base
.stride
;
274 w
= u_minify(res
->width0
, level
);
275 h
= u_minify(res
->height0
, level
);
277 tx
->rect
[0].cpp
= tx
->rect
[1].cpp
= util_format_get_blocksize(res
->format
);
279 tx
->rect
[0].bo
= mt
->base
.bo
;
280 tx
->rect
[0].base
= lvl
->offset
+ layer
* mt
->layer_stride
;
281 tx
->rect
[0].tile_mode
= lvl
->tile_mode
;
282 tx
->rect
[0].x
= util_format_get_nblocksx(res
->format
, box
->x
);
283 tx
->rect
[0].y
= util_format_get_nblocksy(res
->format
, box
->y
);
285 tx
->rect
[0].width
= util_format_get_nblocksx(res
->format
, w
);
286 tx
->rect
[0].height
= util_format_get_nblocksy(res
->format
, h
);
287 tx
->rect
[0].depth
= d
;
288 tx
->rect
[0].pitch
= lvl
->pitch
;
289 tx
->rect
[0].domain
= NOUVEAU_BO_VRAM
;
291 size
= tx
->base
.layer_stride
;
293 ret
= nouveau_bo_new(dev
, NOUVEAU_BO_GART
| NOUVEAU_BO_MAP
, 0,
294 size
* tx
->base
.box
.depth
, &tx
->rect
[1].bo
);
300 tx
->rect
[1].width
= tx
->nblocksx
;
301 tx
->rect
[1].height
= tx
->nblocksy
;
302 tx
->rect
[1].depth
= 1;
303 tx
->rect
[1].pitch
= tx
->base
.stride
;
304 tx
->rect
[1].domain
= NOUVEAU_BO_GART
;
306 if (usage
& PIPE_TRANSFER_READ
) {
308 for (i
= 0; i
< box
->depth
; ++i
) {
309 nvc0_m2mf_transfer_rect(pscreen
, &tx
->rect
[1], &tx
->rect
[0],
310 tx
->nblocksx
, tx
->nblocksy
);
314 tx
->rect
[0].base
+= mt
->layer_stride
;
315 tx
->rect
[1].base
+= size
;
319 tx
->rect
[1].base
= 0;
325 nvc0_miptree_transfer_del(struct pipe_context
*pctx
,
326 struct pipe_transfer
*transfer
)
328 struct pipe_screen
*pscreen
= pctx
->screen
;
329 struct nvc0_transfer
*tx
= (struct nvc0_transfer
*)transfer
;
330 struct nvc0_miptree
*mt
= nvc0_miptree(tx
->base
.resource
);
333 if (tx
->base
.usage
& PIPE_TRANSFER_WRITE
) {
334 for (i
= 0; i
< tx
->base
.box
.depth
; ++i
) {
335 nvc0_m2mf_transfer_rect(pscreen
, &tx
->rect
[0], &tx
->rect
[1],
336 tx
->nblocksx
, tx
->nblocksy
);
340 tx
->rect
[0].base
+= mt
->layer_stride
;
341 tx
->rect
[1].base
+= tx
->nblocksy
* tx
->base
.stride
;
345 nouveau_bo_ref(NULL
, &tx
->rect
[1].bo
);
346 pipe_resource_reference(&transfer
->resource
, NULL
);
352 nvc0_miptree_transfer_map(struct pipe_context
*pctx
,
353 struct pipe_transfer
*transfer
)
355 struct nvc0_transfer
*tx
= (struct nvc0_transfer
*)transfer
;
359 if (tx
->rect
[1].bo
->map
)
360 return tx
->rect
[1].bo
->map
;
362 if (transfer
->usage
& PIPE_TRANSFER_READ
)
363 flags
= NOUVEAU_BO_RD
;
364 if (transfer
->usage
& PIPE_TRANSFER_WRITE
)
365 flags
|= NOUVEAU_BO_WR
;
367 ret
= nouveau_bo_map(tx
->rect
[1].bo
, flags
);
370 return tx
->rect
[1].bo
->map
;
374 nvc0_miptree_transfer_unmap(struct pipe_context
*pctx
,
375 struct pipe_transfer
*transfer
)
377 struct nvc0_transfer
*tx
= (struct nvc0_transfer
*)transfer
;
379 nouveau_bo_unmap(tx
->rect
[1].bo
);