spu_main.c File Reference

Include dependency graph for spu_main.c:

Go to the source code of this file.

Defines
#define	CLEAR_OPT   1
Typedefs
typedef unsigned long	main_param_t
Functions
static void	release_buffer (uint buffer)
	Tell the PPU that this SPU has finished copying a buffer to local store and that it may be reused by the PPU.
static void	really_clear_tiles (uint surfaceIndex)
	For tiles whose status is TILE_STATUS_CLEAR, write solid-filled tiles back to the main framebuffer.
static void	cmd_clear_surface (const struct cell_command_clear_surface *clear)
static void	cmd_release_verts (const struct cell_command_release_verts *release)
static void	cmd_state_fragment_ops (const struct cell_command_fragment_ops *fops)
	Process a CELL_CMD_STATE_FRAGMENT_OPS command.
static void	cmd_state_fragment_program (const struct cell_command_fragment_program *fp)
static void	cmd_state_framebuffer (const struct cell_command_framebuffer *cmd)
static void	cmd_state_sampler (const struct cell_command_sampler *sampler)
static void	cmd_state_texture (const struct cell_command_texture *texture)
static void	cmd_state_vertex_info (const struct vertex_info *vinfo)
static void	cmd_state_vs_array_info (const struct cell_array_info *vs_info)
static void	cmd_state_attrib_fetch (const struct cell_attribute_fetch_code *code)
static void	cmd_finish (void)
static void	cmd_batch (uint opcode)
	Execute a batch of commands which was sent to us by the PPU.
static void	main_loop (void)
	Temporary/simple main loop for SPEs: Get a command, execute it, repeat.
static void	one_time_init (void)
int	main (main_param_t speid, main_param_t argp)
	SPE entrypoint.
Variables
boolean	Debug = FALSE
struct spu_global	spu
struct spu_vs_context	draw
static unsigned char attribute_fetch_code_buffer[136 *PIPE_MAX_ATTRIBS]	ALIGN16_ATTRIB
	Buffers containing dynamically generated SPU code:.

---

Define Documentation

#define CLEAR_OPT   1

---

Typedef Documentation

typedef unsigned long main_param_t

Definition at line 669 of file spu_main.c.

---

Function Documentation

static void cmd_batch

(

uint

opcode

)

[static]

Execute a batch of commands which was sent to us by the PPU.

See the cell_emit_state.c code to see where the commands come from.

The opcode param encodes the location of the buffer and its size.

Definition at line 413 of file spu_main.c.

References ALIGN16_ATTRIB, ASSERT, ASSERT_ALIGN16, cell_buffer_range::base, cell_init_info::buffers, CELL_BUFFER_SIZE, CELL_CMD_BATCH, CELL_CMD_CLEAR_SURFACE, CELL_CMD_FINISH, CELL_CMD_FLUSH_BUFFER_RANGE, CELL_CMD_OPCODE_MASK, CELL_CMD_RELEASE_VERTS, CELL_CMD_RENDER, CELL_CMD_STATE_ATTRIB_FETCH, CELL_CMD_STATE_BIND_VS, CELL_CMD_STATE_FRAGMENT_OPS, CELL_CMD_STATE_FRAGMENT_PROGRAM, CELL_CMD_STATE_FRAMEBUFFER, CELL_CMD_STATE_SAMPLER, CELL_CMD_STATE_TEXTURE, CELL_CMD_STATE_UNIFORMS, CELL_CMD_STATE_VERTEX_INFO, CELL_CMD_STATE_VIEWPORT, CELL_CMD_STATE_VS_ARRAY_INFO, cmd_clear_surface(), cmd_finish(), cmd_release_verts(), cmd_render(), cmd_state_attrib_fetch(), cmd_state_fragment_ops(), cmd_state_fragment_program(), cmd_state_framebuffer(), cmd_state_sampler(), cmd_state_texture(), cmd_state_vertex_info(), cmd_state_vs_array_info(), spu_vs_context::constants, Debug, draw, cell_init_info::id, spu_global::init, release_buffer(), ROUNDUP16, ROUNDUP8, cell_buffer_range::size, spu_vs_context::size, spu, spu_bind_vertex_shader(), spu_dcache_mark_dirty(), TAG_BATCH_BUFFER, spu_vs_context::viewport, and wait_on_mask().

{
   const uint buf = (opcode >> 8) & 0xff;
   uint size = (opcode >> 16);
   uint64_t buffer[CELL_BUFFER_SIZE / 8] ALIGN16_ATTRIB;
   const unsigned usize = size / sizeof(buffer[0]);
   uint pos;

   if (Debug)
      printf("SPU %u: BATCH buffer %u, len %u, from %p\n",
             spu.init.id, buf, size, spu.init.buffers[buf]);

   ASSERT((opcode & CELL_CMD_OPCODE_MASK) == CELL_CMD_BATCH);

   ASSERT_ALIGN16(spu.init.buffers[buf]);

   size = ROUNDUP16(size);

   ASSERT_ALIGN16(spu.init.buffers[buf]);

   mfc_get(buffer,  /* dest */
           (unsigned int) spu.init.buffers[buf],  /* src */
           size,
           TAG_BATCH_BUFFER,
           0, /* tid */
           0  /* rid */);
   wait_on_mask(1 << TAG_BATCH_BUFFER);

   /* Tell PPU we're done copying the buffer to local store */
   if (Debug)
      printf("SPU %u: release batch buf %u\n", spu.init.id, buf);
   release_buffer(buf);

   /*
    * Loop over commands in the batch buffer
    */
   for (pos = 0; pos < usize; /* no incr */) {
      switch (buffer[pos]) {
      /*
       * rendering commands
       */
      case CELL_CMD_CLEAR_SURFACE:
         {
            struct cell_command_clear_surface *clr
               = (struct cell_command_clear_surface *) &buffer[pos];
            cmd_clear_surface(clr);
            pos += sizeof(*clr) / 8;
         }
         break;
      case CELL_CMD_RENDER:
         {
            struct cell_command_render *render
               = (struct cell_command_render *) &buffer[pos];
            uint pos_incr;
            cmd_render(render, &pos_incr);
            pos += pos_incr;
         }
         break;
      /*
       * state-update commands
       */
      case CELL_CMD_STATE_FRAMEBUFFER:
         {
            struct cell_command_framebuffer *fb
               = (struct cell_command_framebuffer *) &buffer[pos];
            cmd_state_framebuffer(fb);
            pos += sizeof(*fb) / 8;
         }
         break;
      case CELL_CMD_STATE_FRAGMENT_OPS:
         {
            struct cell_command_fragment_ops *fops
               = (struct cell_command_fragment_ops *) &buffer[pos];
            cmd_state_fragment_ops(fops);
            pos += sizeof(*fops) / 8;
         }
         break;
      case CELL_CMD_STATE_FRAGMENT_PROGRAM:
         {
            struct cell_command_fragment_program *fp
               = (struct cell_command_fragment_program *) &buffer[pos];
            cmd_state_fragment_program(fp);
            pos += sizeof(*fp) / 8;
         }
         break;
      case CELL_CMD_STATE_SAMPLER:
         {
            struct cell_command_sampler *sampler
               = (struct cell_command_sampler *) &buffer[pos];
            cmd_state_sampler(sampler);
            pos += sizeof(*sampler) / 8;
         }
         break;
      case CELL_CMD_STATE_TEXTURE:
         {
            struct cell_command_texture *texture
               = (struct cell_command_texture *) &buffer[pos];
            cmd_state_texture(texture);
            pos += sizeof(*texture) / 8;
         }
         break;
      case CELL_CMD_STATE_VERTEX_INFO:
         cmd_state_vertex_info((struct vertex_info *) &buffer[pos+1]);
         pos += (1 + ROUNDUP8(sizeof(struct vertex_info)) / 8);
         break;
      case CELL_CMD_STATE_VIEWPORT:
         (void) memcpy(& draw.viewport, &buffer[pos+1],
                       sizeof(struct pipe_viewport_state));
         pos += (1 + ROUNDUP8(sizeof(struct pipe_viewport_state)) / 8);
         break;
      case CELL_CMD_STATE_UNIFORMS:
         draw.constants = (const float (*)[4]) (uintptr_t) buffer[pos + 1];
         pos += 2;
         break;
      case CELL_CMD_STATE_VS_ARRAY_INFO:
         cmd_state_vs_array_info((struct cell_array_info *) &buffer[pos+1]);
         pos += (1 + ROUNDUP8(sizeof(struct cell_array_info)) / 8);
         break;
      case CELL_CMD_STATE_BIND_VS:
#if 0
         spu_bind_vertex_shader(&draw,
                                (struct cell_shader_info *) &buffer[pos+1]);
#endif
         pos += (1 + ROUNDUP8(sizeof(struct cell_shader_info)) / 8);
         break;
      case CELL_CMD_STATE_ATTRIB_FETCH:
         cmd_state_attrib_fetch((struct cell_attribute_fetch_code *)
                                &buffer[pos+1]);
         pos += (1 + ROUNDUP8(sizeof(struct cell_attribute_fetch_code)) / 8);
         break;
      /*
       * misc commands
       */
      case CELL_CMD_FINISH:
         cmd_finish();
         pos += 1;
         break;
      case CELL_CMD_RELEASE_VERTS:
         {
            struct cell_command_release_verts *release
               = (struct cell_command_release_verts *) &buffer[pos];
            cmd_release_verts(release);
            pos += sizeof(*release) / 8;
         }
         break;
      case CELL_CMD_FLUSH_BUFFER_RANGE: {
         struct cell_buffer_range *br = (struct cell_buffer_range *)
             &buffer[pos+1];

         spu_dcache_mark_dirty((unsigned) br->base, br->size);
         pos += (1 + ROUNDUP8(sizeof(struct cell_buffer_range)) / 8);
         break;
      }
      default:
         printf("SPU %u: bad opcode: 0x%llx\n", spu.init.id, buffer[pos]);
         ASSERT(0);
         break;
      }
   }

   if (Debug)
      printf("SPU %u: BATCH complete\n", spu.init.id);

static void cmd_clear_surface

(

const struct cell_command_clear_surface *

clear

)

[static]

Definition at line 134 of file spu_main.c.

References CELL_DEBUG_CHECKER, CELL_DEBUG_SYNC, clear_c_tile(), clear_z_tile(), spu_framebuffer::color_clear_value, Debug, cell_init_info::debug_flags, spu_framebuffer::depth_clear_value, spu_global::fb, spu_framebuffer::height_tiles, cell_init_info::id, spu_global::init, cell_init_info::num_spus, put_tile(), spu, cell_command_clear_surface::surface, TAG_SURFACE_CLEAR, TILE_STATUS_CLEAR, cell_command_clear_surface::value, wait_on_mask(), and spu_framebuffer::width_tiles.

{
   if (Debug)
      printf("SPU %u: CLEAR SURF %u to 0x%08x\n", spu.init.id,
             clear->surface, clear->value);

   if (clear->surface == 0) {
      spu.fb.color_clear_value = clear->value;
      if (spu.init.debug_flags & CELL_DEBUG_CHECKER) {
         uint x = (spu.init.id << 4) | (spu.init.id << 12) |
            (spu.init.id << 20) | (spu.init.id << 28);
         spu.fb.color_clear_value ^= x;
      }
   }
   else {
      spu.fb.depth_clear_value = clear->value;
   }

#define CLEAR_OPT 1
#if CLEAR_OPT

   /* Simply set all tiles' status to CLEAR.
    * When we actually begin rendering into a tile, we'll initialize it to
    * the clear value.  If any tiles go untouched during the frame,
    * really_clear_tiles() will set them to the clear value.
    */
   if (clear->surface == 0) {
      memset(spu.ctile_status, TILE_STATUS_CLEAR, sizeof(spu.ctile_status));
   }
   else {
      memset(spu.ztile_status, TILE_STATUS_CLEAR, sizeof(spu.ztile_status));
   }

#else

   /*
    * This path clears the whole framebuffer to the clear color right now.
    */

   /*
   printf("SPU: %s num=%d w=%d h=%d\n",
          __FUNCTION__, num_tiles, spu.fb.width_tiles, spu.fb.height_tiles);
   */

   /* init a single tile to the clear value */
   if (clear->surface == 0) {
      clear_c_tile(&spu.ctile);
   }
   else {
      clear_z_tile(&spu.ztile);
   }

   /* walk over my tiles, writing the 'clear' tile's data */
   {
      const uint num_tiles = spu.fb.width_tiles * spu.fb.height_tiles;
      uint i;
      for (i = spu.init.id; i < num_tiles; i += spu.init.num_spus) {
         uint tx = i % spu.fb.width_tiles;
         uint ty = i / spu.fb.width_tiles;
         if (clear->surface == 0)
            put_tile(tx, ty, &spu.ctile, TAG_SURFACE_CLEAR, 0);
         else
            put_tile(tx, ty, &spu.ztile, TAG_SURFACE_CLEAR, 1);
      }
   }

   if (spu.init.debug_flags & CELL_DEBUG_SYNC) {
      wait_on_mask(1 << TAG_SURFACE_CLEAR);
   }

#endif /* CLEAR_OPT */

   if (Debug)
      printf("SPU %u: CLEAR SURF done\n", spu.init.id);

static void cmd_finish

(

void

)

[static]

Definition at line 393 of file spu_main.c.

References CELL_CMD_FINISH, Debug, cell_init_info::id, spu_global::init, really_clear_tiles(), and spu.

{
   if (Debug)
      printf("SPU %u: FINISH\n", spu.init.id);
   really_clear_tiles(0);
   /* wait for all outstanding DMAs to finish */
   mfc_write_tag_mask(~0);
   mfc_read_tag_status_all();
   /* send mbox message to PPU */
   spu_write_out_mbox(CELL_CMD_FINISH);

static void cmd_release_verts

(

const struct cell_command_release_verts *

release

)

[static]

Definition at line 211 of file spu_main.c.

References ASSERT, Debug, cell_init_info::id, spu_global::init, release_buffer(), spu, and cell_command_release_verts::vertex_buf.

{
   if (Debug)
      printf("SPU %u: RELEASE VERTS %u\n",
             spu.init.id, release->vertex_buf);
   ASSERT(release->vertex_buf != ~0U);
   release_buffer(release->vertex_buf);

static void cmd_state_attrib_fetch

(

const struct cell_attribute_fetch_code *

code

)

[static]

Definition at line 378 of file spu_main.c.

References cell_attribute_fetch_code::base, spu_vs_context::code, draw, cell_attribute_fetch_code::size, TAG_BATCH_BUFFER, spu_vs_context::vertex_fetch, and wait_on_mask().

{
   mfc_get(attribute_fetch_code_buffer,
           (unsigned int) code->base,  /* src */
           code->size,
           TAG_BATCH_BUFFER,
           0, /* tid */
           0  /* rid */);
   wait_on_mask(1 << TAG_BATCH_BUFFER);

   draw.vertex_fetch.code = attribute_fetch_code_buffer;

static void cmd_state_fragment_ops

(

const struct cell_command_fragment_ops *

fops

)

[static]

Process a CELL_CMD_STATE_FRAGMENT_OPS command.

This involves installing new fragment ops SPU code. If this function is never called, we'll use a regular C fallback function for fragment processing.

Definition at line 228 of file spu_main.c.

References cell_command_fragment_ops::blend, spu_global::blend, cell_command_fragment_ops::code, Debug, pipe_depth_stencil_alpha_state::depth, spu_global::depth_stencil_alpha, cell_command_fragment_ops::dsa, pipe_stencil_state::enabled, pipe_depth_state::enabled, spu_global::fragment_ops, spu_global::fragment_ops_code, cell_init_info::id, spu_global::init, spu_global::read_depth, spu_global::read_stencil, spu, SPU_MAX_FRAGMENT_OPS_INSTS, and pipe_depth_stencil_alpha_state::stencil.

{
   if (Debug)
      printf("SPU %u: CMD_STATE_FRAGMENT_OPS\n", spu.init.id);
   /* Copy SPU code from batch buffer to spu buffer */
   memcpy(spu.fragment_ops_code, fops->code, SPU_MAX_FRAGMENT_OPS_INSTS * 4);
   /* Copy state info (for fallback case only) */
   memcpy(&spu.depth_stencil_alpha, &fops->dsa, sizeof(fops->dsa));
   memcpy(&spu.blend, &fops->blend, sizeof(fops->blend));

   /* Point function pointer at new code */
   spu.fragment_ops = (spu_fragment_ops_func) spu.fragment_ops_code;

   spu.read_depth = spu.depth_stencil_alpha.depth.enabled;
   spu.read_stencil = spu.depth_stencil_alpha.stencil[0].enabled;

static void cmd_state_fragment_program

(

const struct cell_command_fragment_program *

fp

)

[static]

Definition at line 247 of file spu_main.c.

References cell_command_fragment_program::code, Debug, spu_global::fragment_program, spu_global::fragment_program_code, cell_init_info::id, spu_global::init, spu, and SPU_MAX_FRAGMENT_PROGRAM_INSTS.

{
   if (Debug)
      printf("SPU %u: CMD_STATE_FRAGMENT_PROGRAM\n", spu.init.id);
   /* Copy SPU code from batch buffer to spu buffer */
   memcpy(spu.fragment_program_code, fp->code,
          SPU_MAX_FRAGMENT_PROGRAM_INSTS * 4);
#if 01
   /* Point function pointer at new code */
   spu.fragment_program = (spu_fragment_program_func)spu.fragment_program_code;
#endif

static void cmd_state_framebuffer

(

const struct cell_command_framebuffer *

cmd

)

[static]

Definition at line 262 of file spu_main.c.

References ASSERT_ALIGN16, spu_framebuffer::color_format, spu_framebuffer::color_start, cell_command_framebuffer::color_start, Debug, spu_framebuffer::depth_format, cell_command_framebuffer::depth_format, spu_framebuffer::depth_start, cell_command_framebuffer::depth_start, spu_global::fb, spu_framebuffer::height, cell_command_framebuffer::height, spu_framebuffer::height_tiles, cell_init_info::id, spu_global::init, PIPE_FORMAT_S8Z24_UNORM, PIPE_FORMAT_X8Z24_UNORM, PIPE_FORMAT_Z16_UNORM, PIPE_FORMAT_Z24S8_UNORM, PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_Z32_UNORM, spu, TILE_SIZE, spu_framebuffer::width, cell_command_framebuffer::width, spu_framebuffer::width_tiles, spu_framebuffer::zscale, and spu_framebuffer::zsize.

{
   if (Debug)
      printf("SPU %u: FRAMEBUFFER: %d x %d at %p, cformat 0x%x  zformat 0x%x\n",
             spu.init.id,
             cmd->width,
             cmd->height,
             cmd->color_start,
             cmd->color_format,
             cmd->depth_format);

   ASSERT_ALIGN16(cmd->color_start);
   ASSERT_ALIGN16(cmd->depth_start);

   spu.fb.color_start = cmd->color_start;
   spu.fb.depth_start = cmd->depth_start;
   spu.fb.color_format = cmd->color_format;
   spu.fb.depth_format = cmd->depth_format;
   spu.fb.width = cmd->width;
   spu.fb.height = cmd->height;
   spu.fb.width_tiles = (spu.fb.width + TILE_SIZE - 1) / TILE_SIZE;
   spu.fb.height_tiles = (spu.fb.height + TILE_SIZE - 1) / TILE_SIZE;

   switch (spu.fb.depth_format) {
   case PIPE_FORMAT_Z32_UNORM:
      spu.fb.zsize = 4;
      spu.fb.zscale = (float) 0xffffffffu;
      break;
   case PIPE_FORMAT_Z24S8_UNORM:
   case PIPE_FORMAT_S8Z24_UNORM:
   case PIPE_FORMAT_Z24X8_UNORM:
   case PIPE_FORMAT_X8Z24_UNORM:
      spu.fb.zsize = 4;
      spu.fb.zscale = (float) 0x00ffffffu;
      break;
   case PIPE_FORMAT_Z16_UNORM:
      spu.fb.zsize = 2;
      spu.fb.zscale = (float) 0xffffu;
      break;
   default:
      spu.fb.zsize = 0;
      break;
   }

static void cmd_state_sampler

(

const struct cell_command_sampler *

sampler

)

[static]

Definition at line 309 of file spu_main.c.

References Debug, cell_init_info::id, spu_global::init, pipe_sampler_state::min_img_filter, PIPE_TEX_FILTER_LINEAR, spu_global::sample_texture, sample_texture_bilinear(), sample_texture_nearest(), spu_global::sampler, spu, cell_command_sampler::state, and cell_command_sampler::unit.

{
   if (Debug)
      printf("SPU %u: SAMPLER [%u]\n",
             spu.init.id, sampler->unit);

   spu.sampler[sampler->unit] = sampler->state;
   if (spu.sampler[sampler->unit].min_img_filter == PIPE_TEX_FILTER_LINEAR)
      spu.sample_texture[sampler->unit] = sample_texture_bilinear;
   else
      spu.sample_texture[sampler->unit] = sample_texture_nearest;

static void cmd_state_texture

(

const struct cell_command_texture *

texture

)

[static]

Definition at line 324 of file spu_main.c.

References Debug, spu_texture::height, cell_command_texture::height, cell_init_info::id, spu_global::init, spu, spu_texture::start, cell_command_texture::start, spu_texture::tex_size, spu_texture::tex_size_mask, spu_texture::tex_size_x_mask, spu_texture::tex_size_y_mask, spu_global::texture, TILE_SIZE, spu_texture::tiles_per_row, cell_command_texture::unit, spu_texture::width, and cell_command_texture::width.

{
   const uint unit = texture->unit;
   const uint width = texture->width;
   const uint height = texture->height;

   if (Debug) {
      printf("SPU %u: TEXTURE [%u] at %p  size %u x %u\n", spu.init.id,
             texture->unit, texture->start,
             texture->width, texture->height);
   }

   spu.texture[unit].start = texture->start;
   spu.texture[unit].width = width;
   spu.texture[unit].height = height;

   spu.texture[unit].tiles_per_row = width / TILE_SIZE;

   spu.texture[unit].tex_size = (vector float) { width, height, 0.0, 0.0};
   spu.texture[unit].tex_size_mask = (vector unsigned int)
         { width - 1, height - 1, 0, 0 };
   spu.texture[unit].tex_size_x_mask = spu_splats(width - 1);
   spu.texture[unit].tex_size_y_mask = spu_splats(height - 1);

static void cmd_state_vertex_info

(

const struct vertex_info *

vinfo

)

[static]

Definition at line 351 of file spu_main.c.

References ASSERT, Debug, cell_init_info::id, spu_global::init, vertex_info::num_attribs, spu, and spu_global::vertex_info.

{
   if (Debug) {
      printf("SPU %u: VERTEX_INFO num_attribs=%u\n", spu.init.id,
             vinfo->num_attribs);
   }
   ASSERT(vinfo->num_attribs >= 1);
   ASSERT(vinfo->num_attribs <= 8);
   memcpy(&spu.vertex_info, vinfo, sizeof(*vinfo));

static void cmd_state_vs_array_info

(

const struct cell_array_info *

vs_info

)

[static]

Definition at line 364 of file spu_main.c.

References ASSERT, cell_array_info::attr, cell_array_info::base, spu_vs_context::code_offset, spu_vs_context::dirty, draw, cell_array_info::function_offset, PIPE_MAX_ATTRIBS, cell_array_info::pitch, spu_vs_context::pitch, cell_array_info::size, spu_vs_context::size, spu_vs_context::src_ptr, and spu_vs_context::vertex_fetch.

{
   const unsigned attr = vs_info->attr;

   ASSERT(attr < PIPE_MAX_ATTRIBS);
   draw.vertex_fetch.src_ptr[attr] = vs_info->base;
   draw.vertex_fetch.pitch[attr] = vs_info->pitch;
   draw.vertex_fetch.size[attr] = vs_info->size;
   draw.vertex_fetch.code_offset[attr] = vs_info->function_offset;
   draw.vertex_fetch.dirty = 1;

int main	(	main_param_t	speid,
		main_param_t	argp
	)

SPE entrypoint.

Definition at line 676 of file spu_main.c.

References ASSERT, Debug, cell_init_info::id, spu_global::init, main_loop(), one_time_init(), spu, TILE_SIZE, and wait_on_mask().

{
   int tag = 0;

   (void) speid;

   ASSERT(sizeof(tile_t) == TILE_SIZE * TILE_SIZE * 4);
   ASSERT(sizeof(struct cell_command_render) % 8 == 0);

   one_time_init();

   if (Debug)
      printf("SPU: main() speid=%lu\n", (unsigned long) speid);

   mfc_get(&spu.init,  /* dest */
           (unsigned int) argp, /* src */
           sizeof(struct cell_init_info), /* bytes */
           tag,
           0, /* tid */
           0  /* rid */);
   wait_on_mask( 1 << tag );

#if 0
   if (spu.init.id==0)
      spu_test_misc();
#endif

   main_loop();

   return 0;

static void main_loop

(

void

)

[static]

Temporary/simple main loop for SPEs: Get a command, execute it, repeat.

Definition at line 582 of file spu_main.c.

References ASSERT, ASSERT_ALIGN16, CELL_CMD_BATCH, CELL_CMD_EXIT, CELL_CMD_OPCODE_MASK, CELL_CMD_VS_EXECUTE, cell_init_info::cmd, cmd_batch(), Debug, draw, cell_init_info::id, spu_global::init, spu, spu_dcache_report(), spu_execute_vertex_shader(), cell_command::vs, and wait_on_mask().

{
   struct cell_command cmd;
   int exitFlag = 0;

   if (Debug)
      printf("SPU %u: Enter main loop\n", spu.init.id);

   ASSERT((sizeof(struct cell_command) & 0xf) == 0);
   ASSERT_ALIGN16(&cmd);

   while (!exitFlag) {
      unsigned opcode;
      int tag = 0;

      if (Debug)
         printf("SPU %u: Wait for cmd...\n", spu.init.id);

      /* read/wait from mailbox */
      opcode = (unsigned int) spu_read_in_mbox();

      if (Debug)
         printf("SPU %u: got cmd 0x%x\n", spu.init.id, opcode);

      /* command payload */
      mfc_get(&cmd,  /* dest */
              (unsigned int) spu.init.cmd, /* src */
              sizeof(struct cell_command), /* bytes */
              tag,
              0, /* tid */
              0  /* rid */);
      wait_on_mask( 1 << tag );

      /*
       * NOTE: most commands should be contained in a batch buffer
       */

      switch (opcode & CELL_CMD_OPCODE_MASK) {
      case CELL_CMD_EXIT:
         if (Debug)
            printf("SPU %u: EXIT\n", spu.init.id);
         exitFlag = 1;
         break;
      case CELL_CMD_VS_EXECUTE:
#if 0
         spu_execute_vertex_shader(&draw, &cmd.vs);
#endif
         break;
      case CELL_CMD_BATCH:
         cmd_batch(opcode);
         break;
      default:
         printf("Bad opcode!\n");
      }

   }

   if (Debug)
      printf("SPU %u: Exit main loop\n", spu.init.id);

   spu_dcache_report();

static void one_time_init

(

void

)

[static]

< defined in FB, but not in local store

< defined in FB, but not in local store

Definition at line 648 of file spu_main.c.

References spu_global::fragment_ops, invalidate_tex_cache(), spu, spu_fallback_fragment_ops(), and TILE_STATUS_DEFINED.

{
   memset(spu.ctile_status, TILE_STATUS_DEFINED, sizeof(spu.ctile_status));
   memset(spu.ztile_status, TILE_STATUS_DEFINED, sizeof(spu.ztile_status));
   invalidate_tex_cache();

   /* Install default/fallback fragment processing function.
    * This will normally be overriden by a code-gen'd function.
    */
   spu.fragment_ops = spu_fallback_fragment_ops;

static void really_clear_tiles

(

uint

surfaceIndex

)

[static]

For tiles whose status is TILE_STATUS_CLEAR, write solid-filled tiles back to the main framebuffer.

Definition at line 100 of file spu_main.c.

References clear_c_tile(), clear_z_tile(), spu_global::fb, spu_framebuffer::height_tiles, cell_init_info::id, spu_global::init, cell_init_info::num_spus, put_tile(), spu, TAG_SURFACE_CLEAR, TILE_STATUS_CLEAR, wait_on_mask(), and spu_framebuffer::width_tiles.

{
   const uint num_tiles = spu.fb.width_tiles * spu.fb.height_tiles;
   uint i;

   if (surfaceIndex == 0) {
      clear_c_tile(&spu.ctile);

      for (i = spu.init.id; i < num_tiles; i += spu.init.num_spus) {
         uint tx = i % spu.fb.width_tiles;
         uint ty = i / spu.fb.width_tiles;
         if (spu.ctile_status[ty][tx] == TILE_STATUS_CLEAR) {
            put_tile(tx, ty, &spu.ctile, TAG_SURFACE_CLEAR, 0);
         }
      }
   }
   else {
      clear_z_tile(&spu.ztile);

      for (i = spu.init.id; i < num_tiles; i += spu.init.num_spus) {
         uint tx = i % spu.fb.width_tiles;
         uint ty = i / spu.fb.width_tiles;
         if (spu.ztile_status[ty][tx] == TILE_STATUS_CLEAR)
            put_tile(tx, ty, &spu.ctile, TAG_SURFACE_CLEAR, 1);
      }
   }

#if 0
   wait_on_mask(1 << TAG_SURFACE_CLEAR);
#endif
}

static void release_buffer

(

uint

buffer

)

[static]

Tell the PPU that this SPU has finished copying a buffer to local store and that it may be reused by the PPU.

This is done by writting a 16-byte batch-buffer-status block back into main memory (in cell_context->buffer_status[]).

Definition at line 75 of file spu_main.c.

References ALIGN16_ATTRIB, ASSERT, cell_init_info::buffer_status, CELL_BUFFER_STATUS_FREE, CELL_NUM_BUFFERS, cell_init_info::id, spu_global::init, spu, and TAG_MISC.

{
   /* Evidently, using less than a 16-byte status doesn't work reliably */
   static const uint status[4] ALIGN16_ATTRIB
      = {CELL_BUFFER_STATUS_FREE, 0, 0, 0};

   const uint index = 4 * (spu.init.id * CELL_NUM_BUFFERS + buffer);
   uint *dst = spu.init.buffer_status + index;

   ASSERT(buffer < CELL_NUM_BUFFERS);

   mfc_put((void *) &status,    /* src in local memory */
           (unsigned int) dst,  /* dst in main memory */
           sizeof(status),      /* size */
           TAG_MISC,            /* tag is unimportant */
           0, /* tid */
           0  /* rid */);
}

---

Variable Documentation

unsigned char attribute_fetch_code_buffer [136 * PIPE_MAX_ATTRIBS] ALIGN16_ATTRIB [static]

Buffers containing dynamically generated SPU code:.

Definition at line 64 of file spu_main.c.

boolean Debug = FALSE

Definition at line 53 of file spu_main.c.

struct spu_vs_context draw

Definition at line 57 of file spu_main.c.

struct spu_global spu

Definition at line 55 of file spu_main.c.

---