2 * Copyright 2012 Nouveau Project
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
18 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
19 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * Authors: Christoph Bumiller
25 #include "nvc0_context.h"
26 #include "nve4_compute.h"
28 #include "nv50/codegen/nv50_ir_driver.h"
30 static void nve4_compute_dump_launch_desc(const struct nve4_cp_launch_desc
*);
34 nve4_screen_compute_setup(struct nvc0_screen
*screen
,
35 struct nouveau_pushbuf
*push
)
37 struct nouveau_device
*dev
= screen
->base
.device
;
38 struct nouveau_object
*chan
= screen
->base
.channel
;
43 switch (dev
->chipset
& 0xf0) {
45 obj_class
= NVF0_COMPUTE_CLASS
; /* GK110 */
48 obj_class
= NVE4_COMPUTE_CLASS
; /* GK104 */
51 NOUVEAU_ERR("unsupported chipset: NV%02x\n", dev
->chipset
);
55 ret
= nouveau_object_new(chan
, 0xbeef00c0, obj_class
, NULL
, 0,
58 NOUVEAU_ERR("Failed to allocate compute object: %d\n", ret
);
62 ret
= nouveau_bo_new(dev
, NOUVEAU_BO_VRAM
, 0, NVE4_CP_PARAM_SIZE
, NULL
,
67 BEGIN_NVC0(push
, SUBC_COMPUTE(NV01_SUBCHAN_OBJECT
), 1);
68 PUSH_DATA (push
, screen
->compute
->oclass
);
70 BEGIN_NVC0(push
, NVE4_COMPUTE(TEMP_ADDRESS_HIGH
), 2);
71 PUSH_DATAh(push
, screen
->tls
->offset
);
72 PUSH_DATA (push
, screen
->tls
->offset
);
73 /* No idea why there are 2. Divide size by 2 to be safe.
74 * Actually this might be per-MP TEMP size and looks like I'm only using
75 * 2 MPs instead of all 8.
77 BEGIN_NVC0(push
, NVE4_COMPUTE(TEMP_SIZE_HIGH(0)), 3);
78 PUSH_DATAh(push
, screen
->tls_size
/ 2);
79 PUSH_DATA (push
, screen
->tls_size
/ 2);
80 PUSH_DATA (push
, 0xff);
81 BEGIN_NVC0(push
, NVE4_COMPUTE(TEMP_SIZE_HIGH(1)), 3);
82 PUSH_DATAh(push
, screen
->tls_size
/ 2);
83 PUSH_DATA (push
, screen
->tls_size
/ 2);
84 PUSH_DATA (push
, 0xff);
86 /* Unified address space ? Who needs that ? Certainly not OpenCL.
88 * FATAL: Buffers with addresses inside [0x1000000, 0x3000000] will NOT be
89 * accessible. We cannot prevent that at the moment, so expect failure.
91 BEGIN_NVC0(push
, NVE4_COMPUTE(LOCAL_BASE
), 1);
92 PUSH_DATA (push
, 1 << 24);
93 BEGIN_NVC0(push
, NVE4_COMPUTE(SHARED_BASE
), 1);
94 PUSH_DATA (push
, 2 << 24);
96 BEGIN_NVC0(push
, NVE4_COMPUTE(CODE_ADDRESS_HIGH
), 2);
97 PUSH_DATAh(push
, screen
->text
->offset
);
98 PUSH_DATA (push
, screen
->text
->offset
);
100 BEGIN_NVC0(push
, SUBC_COMPUTE(0x0310), 1);
101 PUSH_DATA (push
, (obj_class
>= NVF0_COMPUTE_CLASS
) ? 0x400 : 0x300);
103 /* NOTE: these do not affect the state used by the 3D object */
104 BEGIN_NVC0(push
, NVE4_COMPUTE(TIC_ADDRESS_HIGH
), 3);
105 PUSH_DATAh(push
, screen
->txc
->offset
);
106 PUSH_DATA (push
, screen
->txc
->offset
);
107 PUSH_DATA (push
, NVC0_TIC_MAX_ENTRIES
- 1);
108 BEGIN_NVC0(push
, NVE4_COMPUTE(TSC_ADDRESS_HIGH
), 3);
109 PUSH_DATAh(push
, screen
->txc
->offset
+ 65536);
110 PUSH_DATA (push
, screen
->txc
->offset
+ 65536);
111 PUSH_DATA (push
, NVC0_TSC_MAX_ENTRIES
- 1);
113 if (obj_class
>= NVF0_COMPUTE_CLASS
) {
114 BEGIN_NVC0(push
, SUBC_COMPUTE(0x0248), 1);
115 PUSH_DATA (push
, 0x100);
116 BEGIN_NIC0(push
, SUBC_COMPUTE(0x0248), 63);
117 for (i
= 63; i
>= 1; --i
)
118 PUSH_DATA(push
, 0x38000 | i
);
119 IMMED_NVC0(push
, SUBC_COMPUTE(NV50_GRAPH_SERIALIZE
), 0);
120 IMMED_NVC0(push
, SUBC_COMPUTE(0x518), 0);
123 BEGIN_NVC0(push
, NVE4_COMPUTE(TEX_CB_INDEX
), 1);
124 PUSH_DATA (push
, 0); /* does not interefere with 3D */
126 if (obj_class
>= NVF0_COMPUTE_CLASS
)
127 IMMED_NVC0(push
, SUBC_COMPUTE(0x02c4), 1);
129 /* MS sample coordinate offsets: these do not work with _ALT modes ! */
130 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_ADDRESS_HIGH
), 2);
131 PUSH_DATAh(push
, screen
->parm
->offset
+ NVE4_CP_INPUT_MS_OFFSETS
);
132 PUSH_DATA (push
, screen
->parm
->offset
+ NVE4_CP_INPUT_MS_OFFSETS
);
133 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_SIZE
), 2);
134 PUSH_DATA (push
, 64);
135 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_UNK0184_UNKVAL
);
136 BEGIN_1IC0(push
, NVE4_COMPUTE(UPLOAD_EXEC
), 17);
137 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_EXEC_UNKVAL_DATA
);
138 PUSH_DATA (push
, 0); /* 0 */
140 PUSH_DATA (push
, 1); /* 1 */
142 PUSH_DATA (push
, 0); /* 2 */
144 PUSH_DATA (push
, 1); /* 3 */
146 PUSH_DATA (push
, 2); /* 4 */
148 PUSH_DATA (push
, 3); /* 5 */
150 PUSH_DATA (push
, 2); /* 6 */
152 PUSH_DATA (push
, 3); /* 7 */
154 BEGIN_NVC0(push
, NVE4_COMPUTE(FLUSH
), 1);
155 PUSH_DATA (push
, NVE4_COMPUTE_FLUSH_CB
);
162 nve4_compute_validate_surfaces(struct nvc0_context
*nvc0
)
164 struct nvc0_screen
*screen
= nvc0
->screen
;
165 struct nouveau_pushbuf
*push
= nvc0
->base
.pushbuf
;
166 struct nv50_surface
*sf
;
167 struct nv04_resource
*res
;
170 const unsigned t
= 1;
172 mask
= nvc0
->surfaces_dirty
[t
];
178 * NVE4's surface load/store instructions receive all the information
179 * directly instead of via binding points, so we have to supply them.
181 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_ADDRESS_HIGH
), 2);
182 PUSH_DATAh(push
, screen
->parm
->offset
+ NVE4_CP_INPUT_SUF(i
));
183 PUSH_DATA (push
, screen
->parm
->offset
+ NVE4_CP_INPUT_SUF(i
));
184 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_SIZE
), 2);
185 PUSH_DATA (push
, 64);
186 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_UNK0184_UNKVAL
);
187 BEGIN_1IC0(push
, NVE4_COMPUTE(UPLOAD_EXEC
), 17);
188 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_EXEC_UNKVAL_DATA
);
190 nve4_set_surface_info(push
, nvc0
->surfaces
[t
][i
], screen
);
192 sf
= nv50_surface(nvc0
->surfaces
[t
][i
]);
194 res
= nv04_resource(sf
->base
.texture
);
196 if (sf
->base
.writable
)
197 BCTX_REFN(nvc0
->bufctx_cp
, CP_SUF
, res
, RDWR
);
199 BCTX_REFN(nvc0
->bufctx_cp
, CP_SUF
, res
, RD
);
202 if (nvc0
->surfaces_dirty
[t
]) {
203 BEGIN_NVC0(push
, NVE4_COMPUTE(FLUSH
), 1);
204 PUSH_DATA (push
, NVE4_COMPUTE_FLUSH_CB
);
207 /* re-reference non-dirty surfaces */
208 mask
= nvc0
->surfaces_valid
[t
] & ~nvc0
->surfaces_dirty
[t
];
213 sf
= nv50_surface(nvc0
->surfaces
[t
][i
]);
214 res
= nv04_resource(sf
->base
.texture
);
216 if (sf
->base
.writable
)
217 BCTX_REFN(nvc0
->bufctx_cp
, CP_SUF
, res
, RDWR
);
219 BCTX_REFN(nvc0
->bufctx_cp
, CP_SUF
, res
, RD
);
222 nvc0
->surfaces_dirty
[t
] = 0;
226 /* Thankfully, textures with samplers follow the normal rules. */
228 nve4_compute_validate_samplers(struct nvc0_context
*nvc0
)
230 boolean need_flush
= nve4_validate_tsc(nvc0
, 5);
232 BEGIN_NVC0(nvc0
->base
.pushbuf
, NVE4_COMPUTE(TSC_FLUSH
), 1);
233 PUSH_DATA (nvc0
->base
.pushbuf
, 0);
236 /* (Code duplicated at bottom for various non-convincing reasons.
237 * E.g. we might want to use the COMPUTE subchannel to upload TIC/TSC
238 * entries to avoid a subchannel switch.
239 * Same for texture cache flushes.
240 * Also, the bufctx differs, and more IFs in the 3D version looks ugly.)
242 static void nve4_compute_validate_textures(struct nvc0_context
*);
245 nve4_compute_set_tex_handles(struct nvc0_context
*nvc0
)
247 struct nouveau_pushbuf
*push
= nvc0
->base
.pushbuf
;
249 const unsigned s
= nvc0_shader_stage(PIPE_SHADER_COMPUTE
);
251 uint32_t dirty
= nvc0
->textures_dirty
[s
] | nvc0
->samplers_dirty
[s
];
256 n
= util_logbase2(dirty
) + 1 - i
;
259 address
= nvc0
->screen
->parm
->offset
+ NVE4_CP_INPUT_TEX(i
);
261 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_ADDRESS_HIGH
), 2);
262 PUSH_DATAh(push
, address
);
263 PUSH_DATA (push
, address
);
264 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_SIZE
), 2);
265 PUSH_DATA (push
, n
* 4);
266 PUSH_DATA (push
, 0x1);
267 BEGIN_1IC0(push
, NVE4_COMPUTE(UPLOAD_EXEC
), 1 + n
);
268 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_EXEC_UNKVAL_DATA
);
269 PUSH_DATAp(push
, &nvc0
->tex_handles
[s
][i
], n
);
271 BEGIN_NVC0(push
, NVE4_COMPUTE(FLUSH
), 1);
272 PUSH_DATA (push
, NVE4_COMPUTE_FLUSH_CB
);
274 nvc0
->textures_dirty
[s
] = 0;
275 nvc0
->samplers_dirty
[s
] = 0;
280 nve4_compute_validate_program(struct nvc0_context
*nvc0
)
282 struct nvc0_program
*prog
= nvc0
->compprog
;
287 if (!prog
->translated
) {
288 prog
->translated
= nvc0_program_translate(
289 prog
, nvc0
->screen
->base
.device
->chipset
);
290 if (!prog
->translated
)
293 if (unlikely(!prog
->code_size
))
296 if (likely(prog
->code_size
)) {
297 if (nvc0_program_upload_code(nvc0
, prog
)) {
298 struct nouveau_pushbuf
*push
= nvc0
->base
.pushbuf
;
299 BEGIN_NVC0(push
, NVE4_COMPUTE(FLUSH
), 1);
300 PUSH_DATA (push
, NVE4_COMPUTE_FLUSH_CODE
);
309 nve4_compute_state_validate(struct nvc0_context
*nvc0
)
311 if (!nve4_compute_validate_program(nvc0
))
313 if (nvc0
->dirty_cp
& NVC0_NEW_CP_TEXTURES
)
314 nve4_compute_validate_textures(nvc0
);
315 if (nvc0
->dirty_cp
& NVC0_NEW_CP_SAMPLERS
)
316 nve4_compute_validate_samplers(nvc0
);
317 if (nvc0
->dirty_cp
& (NVC0_NEW_CP_TEXTURES
| NVC0_NEW_CP_SAMPLERS
))
318 nve4_compute_set_tex_handles(nvc0
);
319 if (nvc0
->dirty_cp
& NVC0_NEW_CP_SURFACES
)
320 nve4_compute_validate_surfaces(nvc0
);
321 if (nvc0
->dirty_cp
& NVC0_NEW_CP_GLOBALS
)
322 nvc0_validate_global_residents(nvc0
,
323 nvc0
->bufctx_cp
, NVC0_BIND_CP_GLOBAL
);
325 nvc0_bufctx_fence(nvc0
, nvc0
->bufctx_cp
, FALSE
);
327 nouveau_pushbuf_bufctx(nvc0
->base
.pushbuf
, nvc0
->bufctx_cp
);
328 if (unlikely(nouveau_pushbuf_validate(nvc0
->base
.pushbuf
)))
330 if (unlikely(nvc0
->state
.flushed
))
331 nvc0_bufctx_fence(nvc0
, nvc0
->bufctx_cp
, TRUE
);
338 nve4_compute_upload_input(struct nvc0_context
*nvc0
, const void *input
,
339 const uint
*block_layout
,
340 const uint
*grid_layout
)
342 struct nvc0_screen
*screen
= nvc0
->screen
;
343 struct nouveau_pushbuf
*push
= nvc0
->base
.pushbuf
;
344 struct nvc0_program
*cp
= nvc0
->compprog
;
347 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_ADDRESS_HIGH
), 2);
348 PUSH_DATAh(push
, screen
->parm
->offset
);
349 PUSH_DATA (push
, screen
->parm
->offset
);
350 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_SIZE
), 2);
351 PUSH_DATA (push
, cp
->parm_size
);
352 PUSH_DATA (push
, 0x1);
353 BEGIN_1IC0(push
, NVE4_COMPUTE(UPLOAD_EXEC
), 1 + (cp
->parm_size
/ 4));
354 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_EXEC_UNKVAL_DATA
);
355 PUSH_DATAp(push
, input
, cp
->parm_size
/ 4);
357 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_ADDRESS_HIGH
), 2);
358 PUSH_DATAh(push
, screen
->parm
->offset
+ NVE4_CP_INPUT_GRID_INFO(0));
359 PUSH_DATA (push
, screen
->parm
->offset
+ NVE4_CP_INPUT_GRID_INFO(0));
360 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_SIZE
), 2);
361 PUSH_DATA (push
, 7 * 4);
362 PUSH_DATA (push
, 0x1);
363 BEGIN_1IC0(push
, NVE4_COMPUTE(UPLOAD_EXEC
), 1 + 7);
364 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_EXEC_UNKVAL_DATA
);
365 PUSH_DATAp(push
, block_layout
, 3);
366 PUSH_DATAp(push
, grid_layout
, 3);
369 BEGIN_NVC0(push
, NVE4_COMPUTE(FLUSH
), 1);
370 PUSH_DATA (push
, NVE4_COMPUTE_FLUSH_CB
);
373 static INLINE
uint8_t
374 nve4_compute_derive_cache_split(struct nvc0_context
*nvc0
, uint32_t shared_size
)
376 if (shared_size
> (32 << 10))
377 return NVC0_3D_CACHE_SPLIT_48K_SHARED_16K_L1
;
378 if (shared_size
> (16 << 10))
379 return NVE4_3D_CACHE_SPLIT_32K_SHARED_32K_L1
;
380 return NVC1_3D_CACHE_SPLIT_16K_SHARED_48K_L1
;
384 nve4_compute_setup_launch_desc(struct nvc0_context
*nvc0
,
385 struct nve4_cp_launch_desc
*desc
,
387 const uint
*block_layout
,
388 const uint
*grid_layout
)
390 const struct nvc0_screen
*screen
= nvc0
->screen
;
391 const struct nvc0_program
*cp
= nvc0
->compprog
;
394 nve4_cp_launch_desc_init_default(desc
);
396 desc
->entry
= nvc0_program_symbol_offset(cp
, label
);
398 desc
->griddim_x
= grid_layout
[0];
399 desc
->griddim_y
= grid_layout
[1];
400 desc
->griddim_z
= grid_layout
[2];
401 desc
->blockdim_x
= block_layout
[0];
402 desc
->blockdim_y
= block_layout
[1];
403 desc
->blockdim_z
= block_layout
[2];
405 desc
->shared_size
= align(cp
->cp
.smem_size
, 0x100);
406 desc
->local_size_p
= align(cp
->cp
.lmem_size
, 0x10);
407 desc
->local_size_n
= 0;
408 desc
->cstack_size
= 0x800;
409 desc
->cache_split
= nve4_compute_derive_cache_split(nvc0
, cp
->cp
.smem_size
);
411 desc
->gpr_alloc
= cp
->num_gprs
;
412 desc
->bar_alloc
= cp
->num_barriers
;
414 for (i
= 0; i
< 7; ++i
) {
415 const unsigned s
= 5;
416 if (nvc0
->constbuf
[s
][i
].u
.buf
)
417 nve4_cp_launch_desc_set_ctx_cb(desc
, i
+ 1, &nvc0
->constbuf
[s
][i
]);
419 nve4_cp_launch_desc_set_cb(desc
, 0, screen
->parm
, 0, NVE4_CP_INPUT_SIZE
);
422 static INLINE
struct nve4_cp_launch_desc
*
423 nve4_compute_alloc_launch_desc(struct nouveau_context
*nv
,
424 struct nouveau_bo
**pbo
, uint64_t *pgpuaddr
)
426 uint8_t *ptr
= nouveau_scratch_get(nv
, 512, pgpuaddr
, pbo
);
429 if (*pgpuaddr
& 255) {
430 unsigned adj
= 256 - (*pgpuaddr
& 255);
434 return (struct nve4_cp_launch_desc
*)ptr
;
438 nve4_launch_grid(struct pipe_context
*pipe
,
439 const uint
*block_layout
, const uint
*grid_layout
,
443 struct nvc0_context
*nvc0
= nvc0_context(pipe
);
444 struct nouveau_pushbuf
*push
= nvc0
->base
.pushbuf
;
445 struct nve4_cp_launch_desc
*desc
;
446 uint64_t desc_gpuaddr
;
447 struct nouveau_bo
*desc_bo
;
450 desc
= nve4_compute_alloc_launch_desc(&nvc0
->base
, &desc_bo
, &desc_gpuaddr
);
453 BCTX_REFN_bo(nvc0
->bufctx_cp
, CP_DESC
, NOUVEAU_BO_GART
| NOUVEAU_BO_RD
,
456 ret
= !nve4_compute_state_validate(nvc0
);
460 nve4_compute_setup_launch_desc(nvc0
, desc
, label
, block_layout
, grid_layout
);
461 nve4_compute_dump_launch_desc(desc
);
463 nve4_compute_upload_input(nvc0
, input
, block_layout
, grid_layout
);
465 /* upload descriptor and flush */
467 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_ADDRESS_HIGH
), 2);
468 PUSH_DATAh(push
, desc_gpuaddr
);
469 PUSH_DATA (push
, desc_gpuaddr
);
470 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_SIZE
), 2);
471 PUSH_DATA (push
, 256);
472 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_UNK0184_UNKVAL
);
473 BEGIN_1IC0(push
, NVE4_COMPUTE(UPLOAD_EXEC
), 1 + (256 / 4));
474 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_EXEC_UNKVAL_DESC
);
475 PUSH_DATAp(push
, (const uint32_t *)desc
, 256 / 4);
476 BEGIN_NVC0(push
, NVE4_COMPUTE(FLUSH
), 1);
477 PUSH_DATA (push
, NVE4_COMPUTE_FLUSH_CB
| NVE4_COMPUTE_FLUSH_CODE
);
479 BEGIN_NVC0(push
, NVE4_COMPUTE(LAUNCH_DESC_ADDRESS
), 1);
480 PUSH_DATA (push
, desc_gpuaddr
>> 8);
481 BEGIN_NVC0(push
, NVE4_COMPUTE(LAUNCH
), 1);
482 PUSH_DATA (push
, 0x3);
483 BEGIN_NVC0(push
, SUBC_COMPUTE(NV50_GRAPH_SERIALIZE
), 1);
488 NOUVEAU_ERR("Failed to launch grid !\n");
489 nouveau_scratch_done(&nvc0
->base
);
490 nouveau_bufctx_reset(nvc0
->bufctx_cp
, NVC0_BIND_CP_DESC
);
494 #define NVE4_TIC_ENTRY_INVALID 0x000fffff
497 nve4_compute_validate_textures(struct nvc0_context
*nvc0
)
499 struct nouveau_bo
*txc
= nvc0
->screen
->txc
;
500 struct nouveau_pushbuf
*push
= nvc0
->base
.pushbuf
;
501 const unsigned s
= 5;
503 uint32_t commands
[2][NVE4_CP_INPUT_TEX_MAX
];
504 unsigned n
[2] = { 0, 0 };
506 for (i
= 0; i
< nvc0
->num_textures
[s
]; ++i
) {
507 struct nv50_tic_entry
*tic
= nv50_tic_entry(nvc0
->textures
[s
][i
]);
508 struct nv04_resource
*res
;
509 const boolean dirty
= !!(nvc0
->textures_dirty
[s
] & (1 << i
));
512 nvc0
->tex_handles
[s
][i
] |= NVE4_TIC_ENTRY_INVALID
;
515 res
= nv04_resource(tic
->pipe
.texture
);
518 tic
->id
= nvc0_screen_tic_alloc(nvc0
->screen
, tic
);
520 PUSH_SPACE(push
, 16);
521 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_ADDRESS_HIGH
), 2);
522 PUSH_DATAh(push
, txc
->offset
+ (tic
->id
* 32));
523 PUSH_DATA (push
, txc
->offset
+ (tic
->id
* 32));
524 BEGIN_NVC0(push
, NVE4_COMPUTE(UPLOAD_SIZE
), 2);
525 PUSH_DATA (push
, 32);
526 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_UNK0184_UNKVAL
);
527 BEGIN_1IC0(push
, NVE4_COMPUTE(UPLOAD_EXEC
), 9);
528 PUSH_DATA (push
, NVE4_COMPUTE_UPLOAD_EXEC_UNKVAL_DATA
);
529 PUSH_DATAp(push
, &tic
->tic
[0], 8);
531 commands
[0][n
[0]++] = (tic
->id
<< 4) | 1;
533 if (res
->status
& NOUVEAU_BUFFER_STATUS_GPU_WRITING
) {
534 commands
[1][n
[1]++] = (tic
->id
<< 4) | 1;
536 nvc0
->screen
->tic
.lock
[tic
->id
/ 32] |= 1 << (tic
->id
% 32);
538 res
->status
&= ~NOUVEAU_BUFFER_STATUS_GPU_WRITING
;
539 res
->status
|= NOUVEAU_BUFFER_STATUS_GPU_READING
;
541 nvc0
->tex_handles
[s
][i
] &= ~NVE4_TIC_ENTRY_INVALID
;
542 nvc0
->tex_handles
[s
][i
] |= tic
->id
;
544 BCTX_REFN(nvc0
->bufctx_cp
, CP_TEX(i
), res
, RD
);
546 for (; i
< nvc0
->state
.num_textures
[s
]; ++i
)
547 nvc0
->tex_handles
[s
][i
] |= NVE4_TIC_ENTRY_INVALID
;
550 BEGIN_NIC0(push
, NVE4_COMPUTE(TIC_FLUSH
), n
[0]);
551 PUSH_DATAp(push
, commands
[0], n
[0]);
554 BEGIN_NIC0(push
, NVE4_COMPUTE(TEX_CACHE_CTL
), n
[1]);
555 PUSH_DATAp(push
, commands
[1], n
[1]);
558 nvc0
->state
.num_textures
[s
] = nvc0
->num_textures
[s
];
562 static const char *nve4_cache_split_name(unsigned value
)
565 case NVC1_3D_CACHE_SPLIT_16K_SHARED_48K_L1
: return "16K_SHARED_48K_L1";
566 case NVE4_3D_CACHE_SPLIT_32K_SHARED_32K_L1
: return "32K_SHARED_32K_L1";
567 case NVC0_3D_CACHE_SPLIT_48K_SHARED_16K_L1
: return "48K_SHARED_16K_L1";
574 nve4_compute_dump_launch_desc(const struct nve4_cp_launch_desc
*desc
)
576 const uint32_t *data
= (const uint32_t *)desc
;
578 boolean zero
= FALSE
;
580 debug_printf("COMPUTE LAUNCH DESCRIPTOR:\n");
582 for (i
= 0; i
< sizeof(*desc
); i
+= 4) {
584 debug_printf("[%x]: 0x%08x\n", i
, data
[i
/ 4]);
588 debug_printf("...\n");
593 debug_printf("entry = 0x%x\n", desc
->entry
);
594 debug_printf("grid dimensions = %ux%ux%u\n",
595 desc
->griddim_x
, desc
->griddim_y
, desc
->griddim_z
);
596 debug_printf("block dimensions = %ux%ux%u\n",
597 desc
->blockdim_x
, desc
->blockdim_y
, desc
->blockdim_z
);
598 debug_printf("s[] size: 0x%x\n", desc
->shared_size
);
599 debug_printf("l[] size: -0x%x / +0x%x\n",
600 desc
->local_size_n
, desc
->local_size_p
);
601 debug_printf("stack size: 0x%x\n", desc
->cstack_size
);
602 debug_printf("barrier count: %u\n", desc
->bar_alloc
);
603 debug_printf("$r count: %u\n", desc
->gpr_alloc
);
604 debug_printf("cache split: %s\n", nve4_cache_split_name(desc
->cache_split
));
606 for (i
= 0; i
< 8; ++i
) {
608 uint32_t size
= desc
->cb
[i
].size
;
609 boolean valid
= !!(desc
->cb_mask
& (1 << i
));
611 address
= ((uint64_t)desc
->cb
[i
].address_h
<< 32) | desc
->cb
[i
].address_l
;
613 if (!valid
&& !address
&& !size
)
615 debug_printf("CB[%u]: address = 0x%"PRIx64
", size 0x%x%s\n",
616 i
, address
, size
, valid
? "" : " (invalid)");