23
23
#include "draw/draw_context.h"
25
25
#include "util/u_memory.h"
26
#include "util/u_sampler.h"
26
27
#include "util/u_simple_list.h"
28
#include "util/u_upload_mgr.h"
28
#include "r300_blit.h"
29
31
#include "r300_context.h"
30
32
#include "r300_emit.h"
31
#include "r300_flush.h"
32
#include "r300_query.h"
33
#include "r300_render.h"
33
#include "r300_hyperz.h"
34
34
#include "r300_screen.h"
35
#include "r300_state_invariant.h"
36
#include "r300_texture.h"
38
#include "radeon_winsys.h"
40
static void r300_destroy_context(struct pipe_context* context)
42
struct r300_context* r300 = r300_context(context);
43
struct r300_query* query, * temp;
45
util_blitter_destroy(r300->blitter);
46
draw_destroy(r300->draw);
49
context->screen->buffer_destroy(r300->oqbo);
35
#include "r300_screen_buffer.h"
36
#include "r300_winsys.h"
40
static void r300_update_num_contexts(struct r300_screen *r300screen,
44
p_atomic_inc(&r300screen->num_contexts);
46
if (r300screen->num_contexts > 1)
47
util_mempool_set_thread_safety(&r300screen->pool_buffers,
48
UTIL_MEMPOOL_MULTITHREADED);
50
p_atomic_dec(&r300screen->num_contexts);
52
if (r300screen->num_contexts <= 1)
53
util_mempool_set_thread_safety(&r300screen->pool_buffers,
54
UTIL_MEMPOOL_SINGLETHREADED);
58
static void r300_release_referenced_objects(struct r300_context *r300)
60
struct pipe_framebuffer_state *fb =
61
(struct pipe_framebuffer_state*)r300->fb_state.state;
62
struct r300_textures_state *textures =
63
(struct r300_textures_state*)r300->textures_state.state;
64
struct r300_query *query, *temp;
67
/* Framebuffer state. */
68
util_unreference_framebuffer_state(fb);
71
for (i = 0; i < textures->sampler_view_count; i++)
72
pipe_sampler_view_reference(
73
(struct pipe_sampler_view**)&textures->sampler_views[i], NULL);
75
/* The special dummy texture for texkill. */
76
if (r300->texkill_sampler) {
77
pipe_sampler_view_reference(
78
(struct pipe_sampler_view**)&r300->texkill_sampler,
83
pipe_resource_reference(&r300->vbo, NULL);
86
for (i = 0; i < r300->vertex_buffer_count; i++) {
87
pipe_resource_reference(&r300->vertex_buffer[i].buffer, NULL);
51
90
/* If there are any queries pending or not destroyed, remove them now. */
52
91
foreach_s(query, temp, &r300->query_list) {
53
92
remove_from_list(query);
57
FREE(r300->blend_color_state.state);
58
FREE(r300->clip_state.state);
59
FREE(r300->fb_state.state);
60
FREE(r300->rs_block_state.state);
61
FREE(r300->scissor_state.state);
62
FREE(r300->textures_state.state);
63
FREE(r300->vertex_stream_state.state);
64
FREE(r300->vap_output_state.state);
65
FREE(r300->viewport_state.state);
66
FREE(r300->ztop_state.state);
97
static void r300_destroy_context(struct pipe_context* context)
99
struct r300_context* r300 = r300_context(context);
100
struct r300_atom *atom;
103
util_blitter_destroy(r300->blitter);
105
draw_destroy(r300->draw);
107
/* Print stats, if enabled. */
108
if (SCREEN_DBG_ON(r300->screen, DBG_STATS)) {
109
fprintf(stderr, "r300: Stats for context %p:\n", r300);
110
fprintf(stderr, " : Flushes: %" PRIu64 "\n", r300->flush_counter);
111
foreach(atom, &r300->atom_list) {
112
fprintf(stderr, " : %s: %" PRIu64 " emits\n",
113
atom->name, atom->counter);
118
u_upload_destroy(r300->upload_vb);
120
u_upload_destroy(r300->upload_ib);
122
if (r300->tran.translate_cache)
123
translate_cache_destroy(r300->tran.translate_cache);
125
/* XXX: This function assumes r300->query_list was initialized */
126
r300_release_referenced_objects(r300);
129
r300_hyperz_destroy_mm(r300);
132
r300->rws->cs_destroy(r300->cs);
134
/* XXX: No way to tell if this was initialized or not? */
135
util_mempool_destroy(&r300->pool_transfers);
137
r300_update_num_contexts(r300->screen, -1);
139
/* Free the structs allocated in r300_setup_atoms() */
140
if (r300->aa_state.state) {
141
FREE(r300->aa_state.state);
142
FREE(r300->blend_color_state.state);
143
FREE(r300->clip_state.state);
144
FREE(r300->fb_state.state);
145
FREE(r300->gpu_flush.state);
146
FREE(r300->hyperz_state.state);
147
FREE(r300->invariant_state.state);
148
FREE(r300->rs_block_state.state);
149
FREE(r300->scissor_state.state);
150
FREE(r300->textures_state.state);
151
FREE(r300->vap_invariant_state.state);
152
FREE(r300->viewport_state.state);
153
FREE(r300->ztop_state.state);
154
FREE(r300->fs_constants.state);
155
FREE(r300->vs_constants.state);
156
if (!r300->screen->caps.has_tcl) {
157
FREE(r300->vertex_stream_state.state);
71
r300_is_texture_referenced(struct pipe_context *pipe,
72
struct pipe_texture *texture,
73
unsigned face, unsigned level)
75
struct pipe_buffer* buf = 0;
77
r300_get_texture_buffer(pipe->screen, texture, &buf, NULL);
79
return pipe->is_buffer_referenced(pipe, buf);
83
r300_is_buffer_referenced(struct pipe_context *pipe,
84
struct pipe_buffer *buf)
86
/* This only checks to see whether actual hardware buffers are
87
* referenced. Since we use managed BOs and transfers, it's actually not
88
* possible for pipe_buffers to ever reference the actual hardware, so
89
* buffers are never referenced. */
93
static void r300_flush_cb(void *data)
163
void r300_flush_cb(void *data)
95
165
struct r300_context* const cs_context_copy = data;
116
193
* can affect performance and conformance if not handled with care.
118
195
* Some atoms never change size, others change every emit - those have
119
* the size of 0 here. */
196
* the size of 0 here.
198
* NOTE: The framebuffer state is split into these atoms:
199
* - gpu_flush (unpipelined regs)
200
* - aa_state (unpipelined regs)
201
* - fb_state (unpipelined regs)
202
* - hyperz_state (unpipelined regs followed by pipelined ones)
203
* - fb_state_pipelined (pipelined regs)
204
* The motivation behind this is to be able to emit a strict
205
* subset of the regs, and to have reasonable register ordering. */
120
206
make_empty_list(&r300->atom_list);
121
R300_INIT_ATOM(invariant_state, 71);
207
/* SC, GB (unpipelined), RB3D (unpipelined), ZB (unpipelined). */
208
R300_INIT_ATOM(gpu_flush, 9);
209
R300_INIT_ATOM(aa_state, 4);
210
R300_INIT_ATOM(fb_state, 0);
211
R300_INIT_ATOM(hyperz_state, is_r500 || (is_rv350 && drm_2_6_0) ? 10 : 8);
212
/* ZB (unpipelined), SC. */
122
213
R300_INIT_ATOM(ztop_state, 2);
215
R300_INIT_ATOM(dsa_state, is_r500 ? 8 : 6);
123
217
R300_INIT_ATOM(blend_state, 8);
124
218
R300_INIT_ATOM(blend_color_state, is_r500 ? 3 : 2);
125
R300_INIT_ATOM(clip_state, has_tcl ? 5 + (6 * 4) : 2);
126
R300_INIT_ATOM(dsa_state, is_r500 ? 8 : 6);
127
R300_INIT_ATOM(fb_state, 0);
128
R300_INIT_ATOM(rs_state, 0);
129
220
R300_INIT_ATOM(scissor_state, 3);
221
/* GB, FG, GA, SU, SC, RB3D. */
222
R300_INIT_ATOM(invariant_state, 16 + (is_rv350 ? 4 : 0));
130
224
R300_INIT_ATOM(viewport_state, 9);
131
R300_INIT_ATOM(rs_block_state, 0);
225
R300_INIT_ATOM(pvs_flush, 2);
226
R300_INIT_ATOM(vap_invariant_state, 9);
132
227
R300_INIT_ATOM(vertex_stream_state, 0);
133
R300_INIT_ATOM(vap_output_state, 6);
134
R300_INIT_ATOM(pvs_flush, 2);
135
228
R300_INIT_ATOM(vs_state, 0);
229
R300_INIT_ATOM(vs_constants, 0);
230
R300_INIT_ATOM(clip_state, has_tcl ? 5 + (6 * 4) : 2);
231
/* VAP, RS, GA, GB, SU, SC. */
232
R300_INIT_ATOM(rs_block_state, 0);
233
R300_INIT_ATOM(rs_state, 0);
235
R300_INIT_ATOM(fb_state_pipelined, 5 + (drm_2_3_0 ? 3 : 0));
237
R300_INIT_ATOM(fs, 0);
238
R300_INIT_ATOM(fs_rc_constant_state, 0);
239
R300_INIT_ATOM(fs_constants, 0);
136
241
R300_INIT_ATOM(texture_cache_inval, 2);
137
242
R300_INIT_ATOM(textures_state, 0);
246
R300_INIT_ATOM(hiz_clear, 0);
248
R300_INIT_ATOM(zmask_clear, 0);
250
/* ZB (unpipelined), SU. */
251
R300_INIT_ATOM(query_start, 4);
253
/* Replace emission functions for r500. */
255
r300->fs.emit = r500_emit_fs;
256
r300->fs_rc_constant_state.emit = r500_emit_fs_rc_constant_state;
257
r300->fs_constants.emit = r500_emit_fs_constants;
139
260
/* Some non-CSO atoms need explicit space to store the state locally. */
261
r300->aa_state.state = CALLOC_STRUCT(r300_aa_state);
140
262
r300->blend_color_state.state = CALLOC_STRUCT(r300_blend_color_state);
141
r300->clip_state.state = CALLOC_STRUCT(pipe_clip_state);
263
r300->clip_state.state = CALLOC_STRUCT(r300_clip_state);
142
264
r300->fb_state.state = CALLOC_STRUCT(pipe_framebuffer_state);
265
r300->gpu_flush.state = CALLOC_STRUCT(pipe_framebuffer_state);
266
r300->hyperz_state.state = CALLOC_STRUCT(r300_hyperz_state);
267
r300->invariant_state.state = CALLOC_STRUCT(r300_invariant_state);
143
268
r300->rs_block_state.state = CALLOC_STRUCT(r300_rs_block);
144
269
r300->scissor_state.state = CALLOC_STRUCT(pipe_scissor_state);
145
270
r300->textures_state.state = CALLOC_STRUCT(r300_textures_state);
146
r300->vertex_stream_state.state = CALLOC_STRUCT(r300_vertex_stream_state);
147
r300->vap_output_state.state = CALLOC_STRUCT(r300_vap_output_state);
271
r300->vap_invariant_state.state = CALLOC_STRUCT(r300_vap_invariant_state);
148
272
r300->viewport_state.state = CALLOC_STRUCT(r300_viewport_state);
149
273
r300->ztop_state.state = CALLOC_STRUCT(r300_ztop_state);
274
r300->fs_constants.state = CALLOC_STRUCT(r300_constant_buffer);
275
r300->vs_constants.state = CALLOC_STRUCT(r300_constant_buffer);
276
if (!r300->screen->caps.has_tcl) {
277
r300->vertex_stream_state.state = CALLOC_STRUCT(r300_vertex_stream_state);
280
/* Some non-CSO atoms don't use the state pointer. */
281
r300->fb_state_pipelined.allow_null_state = TRUE;
282
r300->fs_rc_constant_state.allow_null_state = TRUE;
283
r300->pvs_flush.allow_null_state = TRUE;
284
r300->query_start.allow_null_state = TRUE;
285
r300->texture_cache_inval.allow_null_state = TRUE;
287
/* Some states must be marked as dirty here to properly set up
288
* hardware in the first command stream. */
289
r300->invariant_state.dirty = TRUE;
290
r300->pvs_flush.dirty = TRUE;
291
r300->vap_invariant_state.dirty = TRUE;
292
r300->texture_cache_inval.dirty = TRUE;
293
r300->textures_state.dirty = TRUE;
296
/* Not every state tracker calls every driver function before the first draw
297
* call and we must initialize the command buffers somehow. */
298
static void r300_init_states(struct pipe_context *pipe)
300
struct r300_context *r300 = r300_context(pipe);
301
struct pipe_blend_color bc = {{0}};
302
struct pipe_clip_state cs = {{{0}}};
303
struct pipe_scissor_state ss = {0};
304
struct r300_clip_state *clip =
305
(struct r300_clip_state*)r300->clip_state.state;
306
struct r300_gpu_flush *gpuflush =
307
(struct r300_gpu_flush*)r300->gpu_flush.state;
308
struct r300_vap_invariant_state *vap_invariant =
309
(struct r300_vap_invariant_state*)r300->vap_invariant_state.state;
310
struct r300_invariant_state *invariant =
311
(struct r300_invariant_state*)r300->invariant_state.state;
315
pipe->set_blend_color(pipe, &bc);
316
pipe->set_scissor_state(pipe, &ss);
318
/* Initialize the clip state. */
319
if (r300_context(pipe)->screen->caps.has_tcl) {
320
pipe->set_clip_state(pipe, &cs);
322
BEGIN_CB(clip->cb, 2);
323
OUT_CB_REG(R300_VAP_CLIP_CNTL, R300_CLIP_DISABLE);
327
/* Initialize the GPU flush. */
329
BEGIN_CB(gpuflush->cb_flush_clean, 6);
331
/* Flush and free renderbuffer caches. */
332
OUT_CB_REG(R300_RB3D_DSTCACHE_CTLSTAT,
333
R300_RB3D_DSTCACHE_CTLSTAT_DC_FREE_FREE_3D_TAGS |
334
R300_RB3D_DSTCACHE_CTLSTAT_DC_FLUSH_FLUSH_DIRTY_3D);
335
OUT_CB_REG(R300_ZB_ZCACHE_CTLSTAT,
336
R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE |
337
R300_ZB_ZCACHE_CTLSTAT_ZC_FREE_FREE);
339
/* Wait until the GPU is idle.
340
* This fixes random pixels sometimes appearing probably caused
341
* by incomplete rendering. */
342
OUT_CB_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_3D_IDLECLEAN);
346
/* Initialize the VAP invariant state. */
348
BEGIN_CB(vap_invariant->cb, 9);
349
OUT_CB_REG(VAP_PVS_VTX_TIMEOUT_REG, 0xffff);
350
OUT_CB_REG_SEQ(R300_VAP_GB_VERT_CLIP_ADJ, 4);
355
OUT_CB_REG(R300_VAP_PSC_SGN_NORM_CNTL, R300_SGN_NORM_NO_ZERO);
359
/* Initialize the invariant state. */
361
BEGIN_CB(invariant->cb, r300->invariant_state.size);
362
OUT_CB_REG(R300_GB_SELECT, 0);
363
OUT_CB_REG(R300_FG_FOG_BLEND, 0);
364
OUT_CB_REG(R300_GA_ROUND_MODE, 1);
365
OUT_CB_REG(R300_GA_OFFSET, 0);
366
OUT_CB_REG(R300_SU_TEX_WRAP, 0);
367
OUT_CB_REG(R300_SU_DEPTH_SCALE, 0x4B7FFFFF);
368
OUT_CB_REG(R300_SU_DEPTH_OFFSET, 0);
369
OUT_CB_REG(R300_SC_EDGERULE, 0x2DA49525);
371
if (r300->screen->caps.is_rv350) {
372
OUT_CB_REG(R500_RB3D_DISCARD_SRC_PIXEL_LTE_THRESHOLD, 0x01010101);
373
OUT_CB_REG(R500_RB3D_DISCARD_SRC_PIXEL_GTE_THRESHOLD, 0xFEFEFEFE);
378
/* Initialize the hyperz state. */
380
struct r300_hyperz_state *hyperz =
381
(struct r300_hyperz_state*)r300->hyperz_state.state;
382
BEGIN_CB(&hyperz->cb_flush_begin, r300->hyperz_state.size);
383
OUT_CB_REG(R300_ZB_ZCACHE_CTLSTAT,
384
R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE);
385
OUT_CB_REG(R300_ZB_BW_CNTL, 0);
386
OUT_CB_REG(R300_ZB_DEPTHCLEARVALUE, 0);
387
OUT_CB_REG(R300_SC_HYPERZ, R300_SC_HYPERZ_ADJ_2);
389
if (r300->screen->caps.is_r500 ||
390
(r300->screen->caps.is_rv350 &&
391
r300->rws->get_value(r300->rws, R300_VID_DRM_2_6_0))) {
392
OUT_CB_REG(R300_GB_Z_PEQ_CONFIG, 0);
152
398
struct pipe_context* r300_create_context(struct pipe_screen* screen,
155
401
struct r300_context* r300 = CALLOC_STRUCT(r300_context);
156
402
struct r300_screen* r300screen = r300_screen(screen);
157
struct radeon_winsys* radeon_winsys = r300screen->radeon_winsys;
403
struct r300_winsys_screen *rws = r300screen->rws;
162
r300->winsys = radeon_winsys;
164
r300->context.winsys = (struct pipe_winsys*)radeon_winsys;
408
r300_update_num_contexts(r300screen, 1);
411
r300->screen = r300screen;
413
r300->context.winsys = (struct pipe_winsys*)rws;
165
414
r300->context.screen = screen;
166
415
r300->context.priv = priv;
168
417
r300->context.destroy = r300_destroy_context;
170
r300->context.clear = r300_clear;
171
r300->context.surface_copy = r300_surface_copy;
172
r300->context.surface_fill = r300_surface_fill;
174
if (r300screen->caps->has_tcl) {
175
r300->context.draw_arrays = r300_draw_arrays;
176
r300->context.draw_elements = r300_draw_elements;
177
r300->context.draw_range_elements = r300_draw_range_elements;
179
r300->context.draw_arrays = r300_swtcl_draw_arrays;
180
r300->context.draw_elements = r300_draw_elements;
181
r300->context.draw_range_elements = r300_swtcl_draw_range_elements;
419
make_empty_list(&r300->query_list);
421
util_mempool_create(&r300->pool_transfers,
422
sizeof(struct pipe_transfer), 64,
423
UTIL_MEMPOOL_SINGLETHREADED);
425
r300->cs = rws->cs_create(rws);
426
if (r300->cs == NULL)
429
if (!r300screen->caps.has_tcl) {
183
430
/* Create a Draw. This is used for SW TCL. */
184
431
r300->draw = draw_create(&r300->context);
185
432
/* Enable our renderer. */
186
433
draw_set_rasterize_stage(r300->draw, r300_draw_stage(r300));
187
/* Enable Draw's clipping. */
188
draw_set_driver_clipping(r300->draw, FALSE);
189
/* Force Draw to never do viewport transform, since we can do
190
* transform in hardware, always. */
191
draw_set_viewport_state(r300->draw, &r300_viewport_identity);
434
/* Disable converting points/lines to triangles. */
435
draw_wide_line_threshold(r300->draw, 10000000.f);
436
draw_wide_point_threshold(r300->draw, 10000000.f);
194
r300->context.is_texture_referenced = r300_is_texture_referenced;
195
r300->context.is_buffer_referenced = r300_is_buffer_referenced;
197
439
r300_setup_atoms(r300);
199
/* Open up the OQ BO. */
200
r300->oqbo = screen->buffer_create(screen, 4096,
201
PIPE_BUFFER_USAGE_VERTEX, 4096);
202
make_empty_list(&r300->query_list);
441
r300_init_blit_functions(r300);
204
442
r300_init_flush_functions(r300);
206
443
r300_init_query_functions(r300);
208
/* r300_init_surface_functions(r300); */
210
444
r300_init_state_functions(r300);
212
r300->invariant_state.dirty = TRUE;
214
r300->winsys->set_flush_cb(r300->winsys, r300_flush_cb, r300);
215
r300->dirty_state = R300_NEW_KITCHEN_SINK;
445
r300_init_resource_functions(r300);
218
447
r300->blitter = util_blitter_create(&r300->context);
448
if (r300->blitter == NULL)
451
/* Render functions must be initialized after blitter. */
452
r300_init_render_functions(r300);
454
rws->cs_set_flush(r300->cs, r300_flush_cb, r300);
456
/* setup hyper-z mm */
457
if (r300->rws->get_value(r300->rws, R300_CAN_HYPERZ))
458
if (!r300_hyperz_init_mm(r300))
461
r300->upload_ib = u_upload_create(&r300->context,
463
PIPE_BIND_INDEX_BUFFER);
465
if (r300->upload_ib == NULL)
468
r300->upload_vb = u_upload_create(&r300->context,
470
PIPE_BIND_VERTEX_BUFFER);
471
if (r300->upload_vb == NULL)
474
r300->tran.translate_cache = translate_cache_create();
475
if (r300->tran.translate_cache == NULL)
478
r300_init_states(&r300->context);
480
/* The KIL opcode needs the first texture unit to be enabled
481
* on r3xx-r4xx. In order to calm down the CS checker, we bind this
482
* dummy texture there. */
483
if (!r300->screen->caps.is_r500) {
484
struct pipe_resource *tex;
485
struct pipe_resource rtempl = {{0}};
486
struct pipe_sampler_view vtempl = {{0}};
488
rtempl.target = PIPE_TEXTURE_2D;
489
rtempl.format = PIPE_FORMAT_I8_UNORM;
490
rtempl.bind = PIPE_BIND_SAMPLER_VIEW;
494
tex = screen->resource_create(screen, &rtempl);
496
u_sampler_view_default_template(&vtempl, tex, tex->format);
498
r300->texkill_sampler = (struct r300_sampler_view*)
499
r300->context.create_sampler_view(&r300->context, tex, &vtempl);
501
pipe_resource_reference(&tex, NULL);
220
504
return &r300->context;
507
r300_destroy_context(&r300->context);
511
void r300_finish(struct r300_context *r300)
513
struct pipe_framebuffer_state *fb;
516
/* This is a preliminary implementation of glFinish.
518
* The ideal implementation should use something like EmitIrqLocked and
519
* WaitIrq, or better, real fences.
521
if (r300->fb_state.state) {
522
fb = r300->fb_state.state;
524
for (i = 0; i < fb->nr_cbufs; i++) {
525
if (fb->cbufs[i]->texture) {
526
r300->rws->buffer_wait(r300->rws,
527
r300_texture(fb->cbufs[i]->texture)->buffer);
531
if (fb->zsbuf && fb->zsbuf->texture) {
532
r300->rws->buffer_wait(r300->rws,
533
r300_texture(fb->zsbuf->texture)->buffer);