KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

r300g: simplify WRITE_RELOC API and cleanup

This commit is contained in:
Marek Olšák 2011-02-10 06:10:55 +01:00
parent ac366af9fd
commit ce9c0d2801
10 changed files with 130 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
src/gallium/drivers/r300/r300_cb.h
View File

@ -61,40 +61,52 @@
* that they neatly hide away, and don't have the cost of function setup, so
* we're going to use them. */
#ifdef DEBUG
#define CB_DEBUG(x) x
#else
#define CB_DEBUG(x)
#endif
/**
* Command buffer setup.
*/
#define CB_LOCALS \
CB_DEBUG(int cs_count = 0;) \
uint32_t *cs_ptr = NULL; \
CB_DEBUG((void) cs_count;) (void) cs_ptr;
#ifdef DEBUG
#define NEW_CB(ptr, size) do { \
assert(sizeof(*ptr) == sizeof(uint32_t)); \
cs_ptr = (ptr) = (uint32_t*)malloc((size) * sizeof(uint32_t)); \
CB_DEBUG(cs_count = size;) \
} while (0)
#define CB_LOCALS \
int cs_count = 0; \
uint32_t *cs_ptr = NULL; \
(void) cs_count; (void) cs_ptr
#define BEGIN_CB(ptr, size) do { \
assert(sizeof(*ptr) == sizeof(uint32_t)); \
cs_ptr = ptr; \
CB_DEBUG(cs_count = size;) \
assert(sizeof(*(ptr)) == sizeof(uint32_t)); \
cs_count = (size); \
cs_ptr = (ptr); \
} while (0)
#define NEW_CB(ptr, size) \
do { \
assert(sizeof(*(ptr)) == sizeof(uint32_t)); \
cs_count = (size); \
cs_ptr = (ptr) = (uint32_t*)malloc((size) * sizeof(uint32_t)); \
} while (0)
#define END_CB do { \
CB_DEBUG(if (cs_count != 0) \
if (cs_count != 0) \
debug_printf("r300: Warning: cs_count off by %d at (%s, %s:%i)\n", \
cs_count, __FUNCTION__, __FILE__, __LINE__);) \
cs_count, __FUNCTION__, __FILE__, __LINE__); \
} while (0)
#define CB_USED_DW(x) cs_count -= x
#else
#define CB_LOCALS \
uint32_t *cs_ptr = NULL; (void) cs_ptr
#define NEW_CB(ptr, size) \
cs_ptr = (ptr) = (uint32_t*)malloc((size) * sizeof(uint32_t))
#define BEGIN_CB(ptr, size) cs_ptr = (ptr)
#define END_CB
#define CB_USED_DW(x)
#endif
/**
* Storing pure DWORDs.
@ -103,13 +115,13 @@
#define OUT_CB(value) do { \
*cs_ptr = (value); \
cs_ptr++; \
CB_DEBUG(cs_count--;) \
CB_USED_DW(1); \
} while (0)
#define OUT_CB_TABLE(values, count) do { \
memcpy(cs_ptr, values, count * sizeof(uint32_t)); \
cs_ptr += count; \
CB_DEBUG(cs_count -= count;) \
CB_USED_DW(count); \
} while (0)
#define OUT_CB_32F(value) \

4
src/gallium/drivers/r300/r300_context.c
View File

@ -549,13 +549,13 @@ void r300_finish(struct r300_context *r300)
for (i = 0; i < fb->nr_cbufs; i++) {
if (fb->cbufs[i]->texture) {
r300->rws->buffer_wait(r300->rws,
r300_texture(fb->cbufs[i]->texture)->buffer);
r300_texture(fb->cbufs[i]->texture)->buf);
return;
}
}
if (fb->zsbuf && fb->zsbuf->texture) {
r300->rws->buffer_wait(r300->rws,
r300_texture(fb->zsbuf->texture)->buffer);
r300_texture(fb->zsbuf->texture)->buf);
}
}
}

12
src/gallium/drivers/r300/r300_context.h
View File

@ -273,8 +273,8 @@ struct r300_query {
boolean begin_emitted;
/* The buffer where query results are stored. */
struct r300_winsys_buffer *buffer;
struct r300_winsys_cs_buffer *cs_buffer;
struct r300_winsys_buffer *buf;
struct r300_winsys_cs_buffer *cs_buf;
/* The size of the buffer. */
unsigned buffer_size;
/* The domain of the buffer. */
@ -305,8 +305,8 @@ struct r300_surface {
struct pipe_surface base;
/* Winsys buffer backing the texture. */
struct r300_winsys_buffer *buffer;
struct r300_winsys_cs_buffer *cs_buffer;
struct r300_winsys_buffer *buf;
struct r300_winsys_cs_buffer *cs_buf;
enum r300_buffer_domain domain;
@ -394,8 +394,8 @@ struct r300_texture {
enum r300_buffer_domain domain;
/* Pipe buffer backing this texture. */
struct r300_winsys_buffer *buffer;
struct r300_winsys_cs_buffer *cs_buffer;
struct r300_winsys_buffer *buf;
struct r300_winsys_cs_buffer *cs_buf;
/* Registers carrying texture format data. */
/* Only format-independent bits should be filled in. */

55
src/gallium/drivers/r300/r300_cs.h
View File

@ -35,12 +35,6 @@
* that they neatly hide away, and don't have the cost of function setup,so
* we're going to use them. */
#ifdef DEBUG
#define CS_DEBUG(x) x
#else
#define CS_DEBUG(x)
#endif
/**
* Command submission setup.
*/
@ -50,22 +44,29 @@
struct r300_winsys_screen *cs_winsys = (context)->rws; \
int cs_count = 0; (void) cs_count; (void) cs_winsys;
#ifdef DEBUG
#define BEGIN_CS(size) do { \
assert(size <= (R300_MAX_CMDBUF_DWORDS - cs_copy->cdw)); \
CS_DEBUG(cs_count = size;) \
cs_count = size; \
} while (0)
#ifdef DEBUG
#define END_CS do { \
if (cs_count != 0) \
debug_printf("r300: Warning: cs_count off by %d at (%s, %s:%i)\n", \
cs_count, __FUNCTION__, __FILE__, __LINE__); \
cs_count = 0; \
} while (0)
#else
#define END_CS
#endif
#define CS_USED_DW(x) cs_count -= (x)
#else
#define BEGIN_CS(size)
#define END_CS
#define CS_USED_DW(x)
#endif
/**
* Writing pure DWORDs.
@ -73,7 +74,7 @@
#define OUT_CS(value) do { \
cs_copy->buf[cs_copy->cdw++] = (value); \
CS_DEBUG(cs_count--;) \
CS_USED_DW(1); \
} while (0)
#define OUT_CS_32F(value) \
@ -98,7 +99,7 @@
#define OUT_CS_TABLE(values, count) do { \
memcpy(cs_copy->buf + cs_copy->cdw, values, count * 4); \
cs_copy->cdw += count; \
CS_DEBUG(cs_count -= count;) \
CS_USED_DW(count); \
} while (0)
@ -106,27 +107,11 @@
* Writing relocations.
*/
#define OUT_CS_RELOC(bo, offset) do { \
assert(bo); \
OUT_CS(offset); \
cs_winsys->cs_write_reloc(cs_copy, bo); \
CS_DEBUG(cs_count -= 2;) \
} while (0)
#define OUT_CS_BUF_RELOC(bo, offset) do { \
assert(bo); \
OUT_CS_RELOC(r300_buffer(bo)->cs_buf, offset); \
} while (0)
#define OUT_CS_TEX_RELOC(tex, offset) do { \
assert(tex); \
OUT_CS_RELOC(tex->cs_buffer, offset); \
} while (0)
#define OUT_CS_BUF_RELOC_NO_OFFSET(bo) do { \
assert(bo); \
cs_winsys->cs_write_reloc(cs_copy, r300_buffer(bo)->cs_buf); \
CS_DEBUG(cs_count -= 2;) \
#define OUT_CS_RELOC(r) do { \
assert((r)); \
assert((r)->cs_buf); \
cs_winsys->cs_write_reloc(cs_copy, (r)->cs_buf); \
CS_USED_DW(2); \
} while (0)
@ -135,7 +120,7 @@
*/
#define WRITE_CS_TABLE(values, count) do { \
CS_DEBUG(assert(cs_count == 0);) \
assert(cs_count == 0); \
memcpy(cs_copy->buf + cs_copy->cdw, (values), (count) * 4); \
cs_copy->cdw += (count); \
} while (0)

84
src/gallium/drivers/r300/r300_emit.c
View File

@ -352,11 +352,11 @@ void r300_emit_aa_state(struct r300_context *r300, unsigned size, void *state)
OUT_CS_REG(R300_GB_AA_CONFIG, aa->aa_config);
if (aa->dest) {
OUT_CS_REG_SEQ(R300_RB3D_AARESOLVE_OFFSET, 1);
OUT_CS_RELOC(aa->dest->cs_buffer, aa->dest->offset);
OUT_CS_REG(R300_RB3D_AARESOLVE_OFFSET, aa->dest->offset);
OUT_CS_RELOC(aa->dest);
OUT_CS_REG_SEQ(R300_RB3D_AARESOLVE_PITCH, 1);
OUT_CS_RELOC(aa->dest->cs_buffer, aa->dest->pitch);
OUT_CS_REG(R300_RB3D_AARESOLVE_PITCH, aa->dest->pitch);
OUT_CS_RELOC(aa->dest);
}
OUT_CS_REG(R300_RB3D_AARESOLVE_CTL, aa->aaresolve_ctl);
@ -391,11 +391,11 @@ void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
for (i = 0; i < fb->nr_cbufs; i++) {
surf = r300_surface(fb->cbufs[i]);
OUT_CS_REG_SEQ(R300_RB3D_COLOROFFSET0 + (4 * i), 1);
OUT_CS_RELOC(surf->cs_buffer, surf->offset);
OUT_CS_REG(R300_RB3D_COLOROFFSET0 + (4 * i), surf->offset);
OUT_CS_RELOC(surf);
OUT_CS_REG_SEQ(R300_RB3D_COLORPITCH0 + (4 * i), 1);
OUT_CS_RELOC(surf->cs_buffer, surf->pitch);
OUT_CS_REG(R300_RB3D_COLORPITCH0 + (4 * i), surf->pitch);
OUT_CS_RELOC(surf);
}
/* Set up the ZB part of the CBZB clear. */
@ -404,11 +404,11 @@ void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
OUT_CS_REG(R300_ZB_FORMAT, surf->cbzb_format);
OUT_CS_REG_SEQ(R300_ZB_DEPTHOFFSET, 1);
OUT_CS_RELOC(surf->cs_buffer, surf->cbzb_midpoint_offset);
OUT_CS_REG(R300_ZB_DEPTHOFFSET, surf->cbzb_midpoint_offset);
OUT_CS_RELOC(surf);
OUT_CS_REG_SEQ(R300_ZB_DEPTHPITCH, 1);
OUT_CS_RELOC(surf->cs_buffer, surf->cbzb_pitch);
OUT_CS_REG(R300_ZB_DEPTHPITCH, surf->cbzb_pitch);
OUT_CS_RELOC(surf);
DBG(r300, DBG_CBZB,
"CBZB clearing cbuf %08x %08x\n", surf->cbzb_format,
@ -420,11 +420,11 @@ void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
OUT_CS_REG(R300_ZB_FORMAT, surf->format);
OUT_CS_REG_SEQ(R300_ZB_DEPTHOFFSET, 1);
OUT_CS_RELOC(surf->cs_buffer, surf->offset);
OUT_CS_REG(R300_ZB_DEPTHOFFSET, surf->offset);
OUT_CS_RELOC(surf);
OUT_CS_REG_SEQ(R300_ZB_DEPTHPITCH, 1);
OUT_CS_RELOC(surf->cs_buffer, surf->pitch);
OUT_CS_REG(R300_ZB_DEPTHPITCH, surf->pitch);
OUT_CS_RELOC(surf);
if (can_hyperz) {
uint32_t surf_pitch;
@ -568,7 +568,6 @@ static void r300_emit_query_end_frag_pipes(struct r300_context *r300,
struct r300_query *query)
{
struct r300_capabilities* caps = &r300->screen->caps;
struct r300_winsys_cs_buffer *buf = r300->query_current->cs_buffer;
CS_LOCALS(r300);
assert(caps->num_frag_pipes);
@ -586,25 +585,25 @@ static void r300_emit_query_end_frag_pipes(struct r300_context *r300,
case 4:
/* pipe 3 only */
OUT_CS_REG(R300_SU_REG_DEST, 1 << 3);
OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
OUT_CS_RELOC(buf, (query->num_results + 3) * 4);
OUT_CS_REG(R300_ZB_ZPASS_ADDR, (query->num_results + 3) * 4);
OUT_CS_RELOC(r300->query_current);
case 3:
/* pipe 2 only */
OUT_CS_REG(R300_SU_REG_DEST, 1 << 2);
OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
OUT_CS_RELOC(buf, (query->num_results + 2) * 4);
OUT_CS_REG(R300_ZB_ZPASS_ADDR, (query->num_results + 2) * 4);
OUT_CS_RELOC(r300->query_current);
case 2:
/* pipe 1 only */
/* As mentioned above, accomodate RV380 and older. */
OUT_CS_REG(R300_SU_REG_DEST,
1 << (caps->high_second_pipe ? 3 : 1));
OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
OUT_CS_RELOC(buf, (query->num_results + 1) * 4);
OUT_CS_REG(R300_ZB_ZPASS_ADDR, (query->num_results + 1) * 4);
OUT_CS_RELOC(r300->query_current);
case 1:
/* pipe 0 only */
OUT_CS_REG(R300_SU_REG_DEST, 1 << 0);
OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
OUT_CS_RELOC(buf, (query->num_results + 0) * 4);
OUT_CS_REG(R300_ZB_ZPASS_ADDR, (query->num_results + 0) * 4);
OUT_CS_RELOC(r300->query_current);
break;
default:
fprintf(stderr, "r300: Implementation error: Chipset reports %d"
@ -620,13 +619,12 @@ static void r300_emit_query_end_frag_pipes(struct r300_context *r300,
static void rv530_emit_query_end_single_z(struct r300_context *r300,
struct r300_query *query)
{
struct r300_winsys_cs_buffer *buf = r300->query_current->cs_buffer;
CS_LOCALS(r300);
BEGIN_CS(8);
OUT_CS_REG(RV530_FG_ZBREG_DEST, RV530_FG_ZBREG_DEST_PIPE_SELECT_0);
OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
OUT_CS_RELOC(buf, query->num_results * 4);
OUT_CS_REG(R300_ZB_ZPASS_ADDR, query->num_results * 4);
OUT_CS_RELOC(r300->query_current);
OUT_CS_REG(RV530_FG_ZBREG_DEST, RV530_FG_ZBREG_DEST_PIPE_SELECT_ALL);
END_CS;
}
@ -634,16 +632,15 @@ static void rv530_emit_query_end_single_z(struct r300_context *r300,
static void rv530_emit_query_end_double_z(struct r300_context *r300,
struct r300_query *query)
{
struct r300_winsys_cs_buffer *buf = r300->query_current->cs_buffer;
CS_LOCALS(r300);
BEGIN_CS(14);
OUT_CS_REG(RV530_FG_ZBREG_DEST, RV530_FG_ZBREG_DEST_PIPE_SELECT_0);
OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
OUT_CS_RELOC(buf, (query->num_results + 0) * 4);
OUT_CS_REG(R300_ZB_ZPASS_ADDR, (query->num_results + 0) * 4);
OUT_CS_RELOC(r300->query_current);
OUT_CS_REG(RV530_FG_ZBREG_DEST, RV530_FG_ZBREG_DEST_PIPE_SELECT_1);
OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
OUT_CS_RELOC(buf, (query->num_results + 1) * 4);
OUT_CS_REG(R300_ZB_ZPASS_ADDR, (query->num_results + 1) * 4);
OUT_CS_RELOC(r300->query_current);
OUT_CS_REG(RV530_FG_ZBREG_DEST, RV530_FG_ZBREG_DEST_PIPE_SELECT_ALL);
END_CS;
}
@ -803,8 +800,8 @@ void r300_emit_textures_state(struct r300_context *r300,
OUT_CS_REG(R300_TX_FORMAT1_0 + (i * 4), texstate->format.format1);
OUT_CS_REG(R300_TX_FORMAT2_0 + (i * 4), texstate->format.format2);
OUT_CS_REG_SEQ(R300_TX_OFFSET_0 + (i * 4), 1);
OUT_CS_TEX_RELOC(tex, texstate->format.tile_config);
OUT_CS_REG(R300_TX_OFFSET_0 + (i * 4), texstate->format.tile_config);
OUT_CS_RELOC(tex);
}
}
END_CS;
@ -892,7 +889,7 @@ void r300_emit_vertex_arrays(struct r300_context* r300, int offset, boolean inde
for (i = 0; i < vertex_array_count; i++) {
buf = r300_buffer(valid_vbuf[velem[i].vertex_buffer_index]);
OUT_CS_BUF_RELOC_NO_OFFSET(&buf->b.b.b);
OUT_CS_RELOC(buf);
}
END_CS;
}
@ -917,7 +914,8 @@ void r300_emit_vertex_arrays_swtcl(struct r300_context *r300, boolean indexed)
OUT_CS(r300->vertex_info.size |
(r300->vertex_info.size << 8));
OUT_CS(r300->draw_vbo_offset);
OUT_CS_BUF_RELOC(r300->vbo, 0);
OUT_CS(0);
OUT_CS_RELOC(r300_buffer(r300->vbo));
END_CS;
}
@ -1194,15 +1192,15 @@ validate:
/* Color buffers... */
for (i = 0; i < fb->nr_cbufs; i++) {
tex = r300_texture(fb->cbufs[i]->texture);
assert(tex && tex->buffer && "cbuf is marked, but NULL!");
r300->rws->cs_add_reloc(r300->cs, tex->cs_buffer, 0,
assert(tex && tex->buf && "cbuf is marked, but NULL!");
r300->rws->cs_add_reloc(r300->cs, tex->cs_buf, 0,
r300_surface(fb->cbufs[i])->domain);
}
/* ...depth buffer... */
if (fb->zsbuf) {
tex = r300_texture(fb->zsbuf->texture);
assert(tex && tex->buffer && "zsbuf is marked, but NULL!");
r300->rws->cs_add_reloc(r300->cs, tex->cs_buffer, 0,
assert(tex && tex->buf && "zsbuf is marked, but NULL!");
r300->rws->cs_add_reloc(r300->cs, tex->cs_buf, 0,
r300_surface(fb->zsbuf)->domain);
}
}
@ -1214,12 +1212,12 @@ validate:
}
tex = r300_texture(texstate->sampler_views[i]->base.texture);
r300->rws->cs_add_reloc(r300->cs, tex->cs_buffer, tex->domain, 0);
r300->rws->cs_add_reloc(r300->cs, tex->cs_buf, tex->domain, 0);
}
}
/* ...occlusion query buffer... */
if (r300->query_current)
r300->rws->cs_add_reloc(r300->cs, r300->query_current->cs_buffer,
r300->rws->cs_add_reloc(r300->cs, r300->query_current->cs_buf,
0, r300->query_current->domain);
/* ...vertex buffer for SWTCL path... */
if (r300->vbo)

10
src/gallium/drivers/r300/r300_query.c
View File

@ -57,10 +57,10 @@ static struct pipe_query *r300_create_query(struct pipe_context *pipe,
insert_at_tail(&r300->query_list, q);
/* Open up the occlusion query buffer. */
q->buffer = r300->rws->buffer_create(r300->rws, q->buffer_size, 4096,
q->buf = r300->rws->buffer_create(r300->rws, q->buffer_size, 4096,
PIPE_BIND_CUSTOM, PIPE_USAGE_STREAM,
q->domain);
q->cs_buffer = r300->rws->buffer_get_cs_handle(r300->rws, q->buffer);
q->cs_buf = r300->rws->buffer_get_cs_handle(r300->rws, q->buf);
return (struct pipe_query*)q;
}
@ -71,7 +71,7 @@ static void r300_destroy_query(struct pipe_context* pipe,
struct r300_context *r300 = r300_context(pipe);
struct r300_query* q = r300_query(query);
r300->rws->buffer_reference(r300->rws, &q->buffer, NULL);
r300->rws->buffer_reference(r300->rws, &q->buf, NULL);
remove_from_list(q);
FREE(query);
}
@ -137,7 +137,7 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
flags = PIPE_TRANSFER_READ | (!wait ? PIPE_TRANSFER_DONTBLOCK : 0);
map = r300->rws->buffer_map(r300->rws, q->buffer, r300->cs, flags);
map = r300->rws->buffer_map(r300->rws, q->buf, r300->cs, flags);
if (!map)
return FALSE;
@ -148,7 +148,7 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
map++;
}
r300->rws->buffer_unmap(r300->rws, q->buffer);
r300->rws->buffer_unmap(r300->rws, q->buf);
*result = temp;
return TRUE;

9
src/gallium/drivers/r300/r300_render.c
View File

@ -531,17 +531,12 @@ static void r300_emit_draw_elements(struct r300_context *r300,
(alt_num_verts ? R500_VAP_VF_CNTL__USE_ALT_NUM_VERTS : 0));
}
/* INDX_BUFFER is a truly special packet3.
* Unlike most other packet3, where the offset is after the count,
* the order is reversed, so the relocation ends up carrying the
* size of the indexbuf instead of the offset.
*/
OUT_CS_PKT3(R300_PACKET3_INDX_BUFFER, 2);
OUT_CS(R300_INDX_BUFFER_ONE_REG_WR | (R300_VAP_PORT_IDX0 >> 2) |
(0 << R300_INDX_BUFFER_SKIP_SHIFT));
OUT_CS(offset_dwords << 2);
OUT_CS_BUF_RELOC(indexBuffer, count_dwords);
OUT_CS(count_dwords);
OUT_CS_RELOC(r300_buffer(indexBuffer));
END_CS;
}

4
src/gallium/drivers/r300/r300_state.c
View File

@ -625,10 +625,10 @@ static void r300_tex_set_tiling_flags(struct r300_context *r300,
/* Tiling determines how DRM treats the buffer data.
* We must flush CS when changing it if the buffer is referenced. */
if (r300->rws->cs_is_buffer_referenced(r300->cs,
tex->cs_buffer, R300_REF_CS))
tex->cs_buf, R300_REF_CS))
r300->context.flush(&r300->context, 0, NULL);
r300->rws->buffer_set_tiling(r300->rws, tex->buffer,
r300->rws->buffer_set_tiling(r300->rws, tex->buf,
tex->desc.microtile, tex->desc.macrotile[level],
tex->desc.stride_in_bytes[0]);

22
src/gallium/drivers/r300/r300_texture.c
View File

@ -700,7 +700,7 @@ static unsigned r300_texture_is_referenced(struct pipe_context *context,
struct r300_texture *rtex = (struct r300_texture *)texture;
if (r300->rws->cs_is_buffer_referenced(r300->cs,
rtex->cs_buffer, R300_REF_CS))
rtex->cs_buf, R300_REF_CS))
return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
return PIPE_UNREFERENCED;
@ -713,7 +713,7 @@ static void r300_texture_destroy(struct pipe_screen *screen,
struct r300_winsys_screen *rws = (struct r300_winsys_screen *)texture->screen->winsys;
int i;
rws->buffer_reference(rws, &tex->buffer, NULL);
rws->buffer_reference(rws, &tex->buf, NULL);
for (i = 0; i < R300_MAX_TEXTURE_LEVELS; i++) {
if (tex->hiz_mem[i])
u_mmFreeMem(tex->hiz_mem[i]);
@ -733,7 +733,7 @@ static boolean r300_texture_get_handle(struct pipe_screen* screen,
return FALSE;
}
return rws->buffer_get_handle(rws, tex->buffer,
return rws->buffer_get_handle(rws, tex->buf,
tex->desc.stride_in_bytes[0], whandle);
}
@ -786,22 +786,22 @@ r300_texture_create_object(struct r300_screen *rscreen,
tex->domain = base->flags & R300_RESOURCE_FLAG_TRANSFER ?
R300_DOMAIN_GTT :
R300_DOMAIN_VRAM | R300_DOMAIN_GTT;
tex->buffer = buffer;
tex->buf = buffer;
/* Create the backing buffer if needed. */
if (!tex->buffer) {
tex->buffer = rws->buffer_create(rws, tex->desc.size_in_bytes, 2048,
if (!tex->buf) {
tex->buf = rws->buffer_create(rws, tex->desc.size_in_bytes, 2048,
base->bind, base->usage, tex->domain);
if (!tex->buffer) {
if (!tex->buf) {
FREE(tex);
return NULL;
}
}
tex->cs_buffer = rws->buffer_get_cs_handle(rws, tex->buffer);
tex->cs_buf = rws->buffer_get_cs_handle(rws, tex->buf);
rws->buffer_set_tiling(rws, tex->buffer,
rws->buffer_set_tiling(rws, tex->buf,
tex->desc.microtile, tex->desc.macrotile[0],
tex->desc.stride_in_bytes[0]);
@ -899,8 +899,8 @@ struct pipe_surface* r300_create_surface(struct pipe_context * ctx,
surface->base.u.tex.first_layer = surf_tmpl->u.tex.first_layer;
surface->base.u.tex.last_layer = surf_tmpl->u.tex.last_layer;
surface->buffer = tex->buffer;
surface->cs_buffer = tex->cs_buffer;
surface->buf = tex->buf;
surface->cs_buf = tex->cs_buf;
/* Prefer VRAM if there are multiple domains to choose from. */
surface->domain = tex->domain;

12
src/gallium/drivers/r300/r300_transfer.c
View File

@ -90,13 +90,13 @@ r300_texture_get_transfer(struct pipe_context *ctx,
referenced_cs =
r300->rws->cs_is_buffer_referenced(r300->cs,
tex->cs_buffer, R300_REF_CS);
tex->cs_buf, R300_REF_CS);
if (referenced_cs) {
referenced_hw = TRUE;
} else {
referenced_hw =
r300->rws->cs_is_buffer_referenced(r300->cs,
tex->cs_buffer, R300_REF_HW);
tex->cs_buf, R300_REF_HW);
}
blittable = ctx->screen->is_format_supported(
@ -235,12 +235,12 @@ void* r300_texture_transfer_map(struct pipe_context *ctx,
/* The detiled texture is of the same size as the region being mapped
* (no offset needed). */
return rws->buffer_map(rws,
r300transfer->linear_texture->buffer,
r300transfer->linear_texture->buf,
r300->cs,
transfer->usage);
} else {
/* Tiling is disabled. */
map = rws->buffer_map(rws, tex->buffer, r300->cs,
map = rws->buffer_map(rws, tex->buf, r300->cs,
transfer->usage);
if (!map) {
@ -261,8 +261,8 @@ void r300_texture_transfer_unmap(struct pipe_context *ctx,
struct r300_texture *tex = r300_texture(transfer->resource);
if (r300transfer->linear_texture) {
rws->buffer_unmap(rws, r300transfer->linear_texture->buffer);
rws->buffer_unmap(rws, r300transfer->linear_texture->buf);
} else {
rws->buffer_unmap(rws, tex->buffer);
rws->buffer_unmap(rws, tex->buf);
}
}