fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-06 15:58:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

cell: attempt conversion to sw_winsys

Browse source
This commit is contained in:
Keith Whitwell 2010-03-09 12:31:20 +00:00
parent 8ac10162f1
commit fe94a363e5
11 changed files with 324 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/gallium/drivers/cell/ppu/Makefile
View file

@ -21,6 +21,7 @@ SPU_CODE_MODULE = ../spu/g3d_spu.a
SOURCES = \
cell_batch.c \
cell_buffer.c \
cell_clear.c \
cell_context.c \
cell_draw_arrays.c \

118
src/gallium/drivers/cell/ppu/cell_buffer.c Normal file
View file

@ -0,0 +1,118 @@
/**************************************************************************
*
* Copyright 2009 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "util/u_inlines.h"
#include "util/u_memory.h"
#include "util/u_math.h"
#include "sp_screen.h"
#include "sp_buffer.h"
static void *
cell_buffer_map(struct pipe_screen *screen,
struct pipe_buffer *buf,
unsigned flags)
{
struct cell_buffer *cell_buf = cell_buffer(buf);
return cell_buf->data;
}
static void
cell_buffer_unmap(struct pipe_screen *screen,
struct pipe_buffer *buf)
{
}
static void
cell_buffer_destroy(struct pipe_buffer *buf)
{
struct cell_buffer *sbuf = cell_buffer(buf);
if (!sbuf->userBuffer)
align_free(sbuf->data);
FREE(sbuf);
}
static struct pipe_buffer *
cell_buffer_create(struct pipe_screen *screen,
unsigned alignment,
unsigned usage,
unsigned size)
{
struct cell_buffer *buffer = CALLOC_STRUCT(cell_buffer);
pipe_reference_init(&buffer->base.reference, 1);
buffer->base.screen = screen;
buffer->base.alignment = MAX2(alignment, 16);
buffer->base.usage = usage;
buffer->base.size = size;
buffer->data = align_malloc(size, alignment);
return &buffer->base;
}
/**
* Create buffer which wraps user-space data.
*/
static struct pipe_buffer *
cell_user_buffer_create(struct pipe_screen *screen,
void *ptr,
unsigned bytes)
{
struct cell_buffer *buffer;
buffer = CALLOC_STRUCT(cell_buffer);
if(!buffer)
return NULL;
pipe_reference_init(&buffer->base.reference, 1);
buffer->base.screen = screen;
buffer->base.size = bytes;
buffer->userBuffer = TRUE;
buffer->data = ptr;
return &buffer->base;
}
void
cell_init_screen_buffer_funcs(struct pipe_screen *screen)
{
screen->buffer_create = cell_buffer_create;
screen->user_buffer_create = cell_user_buffer_create;
screen->buffer_map = cell_buffer_map;
screen->buffer_unmap = cell_buffer_unmap;
screen->buffer_destroy = cell_buffer_destroy;
}

42
src/gallium/drivers/cell/ppu/cell_winsys.h → src/gallium/drivers/cell/ppu/cell_buffer.h
View file

@ -1,8 +1,8 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
*
* Copyright 2009 VMware, Inc.
* All Rights Reserved.
*
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
@ -10,38 +10,46 @@
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*
**************************************************************************/
#ifndef CELL_WINSYS_H
#define CELL_WINSYS_H
#ifndef SP_BUFFER_H
#define SP_BUFFER_H
#include "pipe/p_compiler.h"
#include "pipe/p_state.h"
/**
* Very simple winsys at this time.
* Will probably eventually add SPU control info.
*/
struct cell_winsys
struct cell_buffer
{
uint dummy;
struct pipe_buffer base;
boolean userBuffer; /** Is this a user-space buffer? */
void *data;
};
/** Cast wrapper */
static INLINE struct cell_buffer *
cell_buffer( struct pipe_buffer *buf )
{
return (struct cell_buffer *)buf;
}
#endif
void
cell_init_screen_buffer_funcs(struct pipe_screen *screen);
#endif /* SP_BUFFER_H */

2
src/gallium/drivers/cell/ppu/cell_context.c
View file

@ -136,7 +136,7 @@ cell_create_context(struct pipe_screen *screen,
memset(cell, 0, sizeof(*cell));
cell->winsys = NULL; /* XXX: fixme - get this from screen? */
cell->pipe.winsys = screen->winsys;
cell->pipe.winsys = NULL;
cell->pipe.screen = screen;
cell->pipe.priv = priv;
cell->pipe.destroy = cell_destroy_context;

51
src/gallium/drivers/cell/ppu/cell_draw_arrays.c
View file

@ -39,41 +39,12 @@
#include "cell_draw_arrays.h"
#include "cell_state.h"
#include "cell_flush.h"
#include "cell_buffer.h"
#include "draw/draw_context.h"
static void
cell_map_constant_buffers(struct cell_context *sp)
{
struct pipe_winsys *ws = sp->pipe.winsys;
uint i;
for (i = 0; i < 2; i++) {
if (sp->constants[i] && sp->constants[i]->size) {
sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i],
PIPE_BUFFER_USAGE_CPU_READ);
cell_flush_buffer_range(sp, sp->mapped_constants[i],
sp->constants[i]->size);
}
}
draw_set_mapped_constant_buffer(sp->draw, PIPE_SHADER_VERTEX, 0,
sp->mapped_constants[PIPE_SHADER_VERTEX],
sp->constants[PIPE_SHADER_VERTEX]->size);
}
static void
cell_unmap_constant_buffers(struct cell_context *sp)
{
struct pipe_winsys *ws = sp->pipe.winsys;
uint i;
for (i = 0; i < 2; i++) {
if (sp->constants[i] && sp->constants[i]->size)
ws->buffer_unmap(ws, sp->constants[i]);
sp->mapped_constants[i] = NULL;
}
}
@ -102,23 +73,17 @@ cell_draw_range_elements(struct pipe_context *pipe,
#if 0
cell_map_surfaces(sp);
#endif
cell_map_constant_buffers(sp);
/*
* Map vertex buffers
*/
for (i = 0; i < sp->num_vertex_buffers; i++) {
void *buf = pipe_buffer_map(pipe->screen,
sp->vertex_buffer[i].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
cell_flush_buffer_range(sp, buf, sp->vertex_buffer[i].buffer->size);
void *buf = cell_buffer(cell->vertex_buffer[i].buffer)->data;
draw_set_mapped_vertex_buffer(draw, i, buf);
}
/* Map index buffer, if present */
if (indexBuffer) {
void *mapped_indexes = pipe_buffer_map(pipe->screen,
indexBuffer,
PIPE_BUFFER_USAGE_CPU_READ);
void *mapped_indexes = cell_buffer(indexBuffer)->data;
draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
}
else {
@ -135,15 +100,17 @@ cell_draw_range_elements(struct pipe_context *pipe,
*/
for (i = 0; i < sp->num_vertex_buffers; i++) {
draw_set_mapped_vertex_buffer(draw, i, NULL);
pipe_buffer_unmap(pipe->screen, sp->vertex_buffer[i].buffer);
}
if (indexBuffer) {
draw_set_mapped_element_buffer(draw, 0, NULL);
pipe_buffer_unmap(pipe->screen, indexBuffer);
}
/* Note: leave drawing surfaces mapped */
cell_unmap_constant_buffers(sp);
/*
* TODO: Flush only when a user vertex/index buffer is present
* (or even better, modify draw module to do this
* internally when this condition is seen?)
*/
draw_flush(draw);
}

61
src/gallium/drivers/cell/ppu/cell_screen.c
View file

@ -35,7 +35,9 @@
#include "cell_context.h"
#include "cell_screen.h"
#include "cell_texture.h"
#include "cell_winsys.h"
#include "cell_buffer.h"
#include "state_tracker/sw_winsys.h"
static const char *
@ -133,19 +135,28 @@ cell_is_format_supported( struct pipe_screen *screen,
unsigned tex_usage,
unsigned geom_flags )
{
/* cell supports most formats, XXX for now anyway */
struct sw_winsys *winsys = cell_screen(screen)->winsys;
if (format == PIPE_FORMAT_DXT5_RGBA ||
format == PIPE_FORMAT_A8B8G8R8_SRGB)
return FALSE;
else
return TRUE;
if (tex_usage & PIPE_TEXTURE_USAGE_DISPLAY_TARGET) {
if (!winsys->is_displaytarget_format_supported(winsys, format))
return FALSE;
}
/* This is often a lie. Pull in logic from llvmpipe to fix.
*/
return TRUE;
}
static void
cell_destroy_screen( struct pipe_screen *screen )
{
struct pipe_winsys *winsys = screen->winsys;
struct cell_screen *sp_screen = cell_screen(screen);
struct sw_winsys *winsys = sp_screen->winsys;
if(winsys->destroy)
winsys->destroy(winsys);
@ -153,6 +164,23 @@ cell_destroy_screen( struct pipe_screen *screen )
FREE(screen);
}
/* This used to be overriden by the co-state tracker, but really needs
* to be active with sw_winsys.
*/
static void
cell_flush_frontbuffer(struct pipe_screen *_screen,
struct pipe_surface *surface,
void *context_private)
{
struct cell_screen *screen = cell_screen(_screen);
struct sw_winsys *winsys = screen->winsys;
struct cell_texture *texture = cell_texture(surface->texture);
assert(texture->dt);
if (texture->dt)
winsys->displaytarget_display(winsys, texture->dt, context_private);
}
/**
* Create a new pipe_screen object
@ -160,26 +188,27 @@ cell_destroy_screen( struct pipe_screen *screen )
* that would be the place to put SPU thread/context info...
*/
struct pipe_screen *
cell_create_screen(struct pipe_winsys *winsys)
cell_create_screen(struct sw_winsys *winsys)
{
struct pipe_screen *screen = CALLOC_STRUCT(pipe_screen);
struct cell_screen *screen = CALLOC_STRUCT(pipe_screen);
if (!screen)
return NULL;
screen->winsys = winsys;
screen->base.winsys = NULL;
screen->destroy = cell_destroy_screen;
screen->base.destroy = cell_destroy_screen;
screen->get_name = cell_get_name;
screen->get_vendor = cell_get_vendor;
screen->get_param = cell_get_param;
screen->get_paramf = cell_get_paramf;
screen->is_format_supported = cell_is_format_supported;
screen->context_create = cell_create_context;
screen->base.get_name = cell_get_name;
screen->base.get_vendor = cell_get_vendor;
screen->base.get_param = cell_get_param;
screen->base.get_paramf = cell_get_paramf;
screen->base.is_format_supported = cell_is_format_supported;
screen->base.context_create = cell_create_context;
cell_init_screen_texture_funcs(screen);
u_simple_screen_init(screen);
cell_init_screen_texture_funcs(&screen->base);
cell_init_screen_buffer_funcs(&screen->base);
return screen;
}

23
src/gallium/drivers/cell/ppu/cell_screen.h
View file

@ -30,12 +30,29 @@
#define CELL_SCREEN_H
struct pipe_screen;
struct pipe_winsys;
#include "pipe/p_screen.h"
struct sw_winsys;
struct cell_screen {
struct pipe_screen base;
struct sw_winsys *winsys;
/* Increments whenever textures are modified. Contexts can track
* this.
*/
unsigned timestamp;
};
static INLINE struct cell_screen *
cell_screen( struct pipe_screen *pipe )
{
return (struct cell_screen *)pipe;
}
extern struct pipe_screen *
cell_create_screen(struct pipe_winsys *winsys);
cell_create_screen(struct sw_winsys *winsys);
#endif /* CELL_SCREEN_H */

5
src/gallium/drivers/cell/ppu/cell_state_emit.c
View file

@ -245,16 +245,13 @@ cell_emit_state(struct cell_context *cell)
uint i, j;
float *buf = cell_batch_alloc16(cell, ROUNDUP16(32 + num_const * sizeof(float)));
uint32_t *ibuf = (uint32_t *) buf;
const float *constants = pipe_buffer_map(cell->pipe.screen,
cell->constants[shader],
PIPE_BUFFER_USAGE_CPU_READ);
const float *constants = cell->mapped_constants[shader];
ibuf[0] = CELL_CMD_STATE_FS_CONSTANTS;
ibuf[4] = num_const;
j = 8;
for (i = 0; i < num_const; i++) {
buf[j++] = constants[i];
}
pipe_buffer_unmap(cell->pipe.screen, cell->constants[shader]);
}
if (cell->dirty & (CELL_NEW_FRAMEBUFFER |

13
src/gallium/drivers/cell/ppu/cell_state_shader.c
View file

@ -34,6 +34,7 @@
#include "cell_context.h"
#include "cell_state.h"
#include "cell_gen_fp.h"
#include "cell_buffer.h"
/** cast wrapper */
@ -185,15 +186,27 @@ cell_set_constant_buffer(struct pipe_context *pipe,
struct pipe_buffer *buf)
{
struct cell_context *cell = cell_context(pipe);
unsigned size = constants ? constants->size : 0;
const void *data = constants ? cell_buffer(constants)->data : NULL;
assert(shader < PIPE_SHADER_TYPES);
assert(index == 0);
if (cell->constants[shader] == constants)
return;
draw_flush(cell->draw);
/* note: reference counting */
pipe_buffer_reference(&cell->constants[shader], buf);
if(shader == PIPE_SHADER_VERTEX) {
draw_set_mapped_constant_buffer(cell->draw, PIPE_SHADER_VERTEX, 0,
data, size);
}
cell->mapped_constants[shader] = data;
if (shader == PIPE_SHADER_VERTEX)
cell->dirty |= CELL_NEW_VS_CONSTANTS;
else if (shader == PIPE_SHADER_FRAGMENT)

97
src/gallium/drivers/cell/ppu/cell_texture.c
View file

@ -43,10 +43,13 @@
#include "cell_state.h"
#include "cell_texture.h"
#include "state_tracker/sw_winsys.h"
static void
cell_texture_layout(struct cell_texture *ct)
static boolean
cell_texture_layout(struct pipe_screen *screen,
struct cell_texture *ct)
{
struct pipe_texture *pt = &ct->base;
unsigned level;
@ -82,9 +85,34 @@ cell_texture_layout(struct cell_texture *ct)
height = u_minify(height, 1);
depth = u_minify(depth, 1);
}
ct->data = align_malloc(ct->buffer_size, 16);
return ct->data != NULL;
}
/**
* Texture layout for simple color buffers.
*/
static boolean
cell_displaytarget_layout(struct pipe_screen *screen,
struct cell_texture * ct)
{
struct sw_winsys *winsys = cell_screen(screen)->winsys;
/* Round up the surface size to a multiple of the tile size?
*/
ct->dt = winsys->displaytarget_create(winsys,
ct->base.format,
ct->base.width0,
ct->base.height0,
16,
&ct->stride[0] );
return ct->dt != NULL;
}
static struct pipe_texture *
cell_texture_create(struct pipe_screen *screen,
const struct pipe_texture *templat)
@ -97,31 +125,46 @@ cell_texture_create(struct pipe_screen *screen,
pipe_reference_init(&ct->base.reference, 1);
ct->base.screen = screen;
cell_texture_layout(ct);
ct->buffer = screen->buffer_create(screen, 32, PIPE_BUFFER_USAGE_PIXEL,
ct->buffer_size);
if (!ct->buffer) {
FREE(ct);
return NULL;
if (ct->base.tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
PIPE_TEXTURE_USAGE_SCANOUT |
PIPE_TEXTURE_USAGE_SHARED)) {
if (!cell_displaytarget_layout(screen, ct))
goto fail;
}
else {
if (!cell_texture_layout(screen, ct))
goto fail;
}
return &ct->base;
fail:
FREE(ct);
return NULL;
}
static void
cell_texture_destroy(struct pipe_texture *pt)
{
struct cell_screen *screen = cell_screen(pt->screen);
struct sw_winsys *winsys = screen->winsys;
struct cell_texture *ct = cell_texture(pt);
if (ct->mapped) {
pipe_buffer_unmap(ct->buffer->screen, ct->buffer);
if (ct->dt)
winsys->displaytarget_unmap(winsys, ct->dt);
ct->mapped = NULL;
}
pipe_buffer_reference(&ct->buffer, NULL);
if (ct->dt) {
/* display target */
winsys->displaytarget_destroy(winsys, ct->dt);
}
else {
/* regular texture */
align_free(ct->data);
}
FREE(ct);
}
@ -388,12 +431,20 @@ cell_transfer_map(struct pipe_screen *screen, struct pipe_transfer *transfer)
assert(transfer->texture);
if (!ct->mapped) {
/* map now */
ct->mapped = pipe_buffer_map(screen, ct->buffer,
pipe_transfer_buffer_flags(transfer));
if (ct->mapped == NULL) {
if (ct->dt) {
struct sw_winsys *winsys = cell_screen(screen)->winsys;
ct->mapped = winsys->displaytarget_map(screen, ct->dt,
pipe_transfer_buffer_flags(transfer));
}
else {
ct->mapped = ct->data;
}
}
if (ct->mapped == NULL)
return NULL;
/*
* Create a buffer of ordinary memory for the linear texture.
* This is the memory that the user will read/write.
@ -441,9 +492,8 @@ cell_transfer_unmap(struct pipe_screen *screen,
const uint stride = ct->stride[level];
if (!ct->mapped) {
/* map now */
ct->mapped = pipe_buffer_map(screen, ct->buffer,
PIPE_BUFFER_USAGE_CPU_READ);
assert(0);
return;
}
if (transfer->usage & PIPE_TRANSFER_WRITE) {
@ -461,11 +511,20 @@ cell_transfer_unmap(struct pipe_screen *screen,
}
}
if (ct->dt) {
/* display target */
struct sw_winsys *winsys = cell_screen(screen)->winsys;
winsys->displaytarget_unmap(winsys, ct->dt);
}
align_free(ctrans->map);
ctrans->map = NULL;
}
void
cell_init_screen_texture_funcs(struct pipe_screen *screen)
{

15
src/gallium/drivers/cell/ppu/cell_texture.h
View file

@ -43,8 +43,19 @@ struct cell_texture
unsigned long level_offset[CELL_MAX_TEXTURE_LEVELS];
unsigned long stride[CELL_MAX_TEXTURE_LEVELS];
/** The tiled texture data is held in this buffer */
struct pipe_buffer *buffer;
/**
* Display target, for textures with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET
* usage.
*/
struct sw_displaytarget *dt;
/**
* Malloc'ed data for regular textures, or a mapping to dt above.
*/
void *data;
/* Size of the linear buffer??
*/
unsigned long buffer_size;
/** The buffer above, mapped. This is the memory from which the