src/gallium/drivers/cell/common.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /**
  29  * Types and tokens which are common to the SPU and PPU code.
  30  */
  31
  32
  33 #ifndef CELL_COMMON_H
  34 #define CELL_COMMON_H
  35
  36 #include "pipe/p_compiler.h"
  37 #include "pipe/p_format.h"
  38 #include "pipe/p_state.h"
  39
  40
  41 /** The standard assert macro doesn't seem to work reliably */
  42 #define ASSERT(x) \
  43    if (!(x)) { \
  44       ubyte *p = NULL; \
  45       fprintf(stderr, "%s:%d: %s(): assertion %s failed.\n", \
  46               __FILE__, __LINE__, __FUNCTION__, #x);             \
  47       *p = 0; \
  48       exit(1); \
  49    }
  50
  51
  52 /** for sanity checking */
  53 #define ASSERT_ALIGN16(ptr) \
  54   ASSERT((((unsigned long) (ptr)) & 0xf) == 0);
  55
  56
  57 /** round up value to next multiple of 4 */
  58 #define ROUNDUP4(k)  (((k) + 0x3) & ~0x3)
  59
  60 /** round up value to next multiple of 8 */
  61 #define ROUNDUP8(k)  (((k) + 0x7) & ~0x7)
  62
  63 /** round up value to next multiple of 16 */
  64 #define ROUNDUP16(k)  (((k) + 0xf) & ~0xf)
  65
  66
  67 #define CELL_MAX_SPUS 6
  68
  69 #define CELL_MAX_SAMPLERS 4
  70 #define CELL_MAX_TEXTURE_LEVELS 12  /* 2k x 2k */
  71 #define CELL_MAX_CONSTANTS 32  /**< number of float[4] constants */
  72 #define CELL_MAX_WIDTH 1024    /**< max framebuffer width */
  73 #define CELL_MAX_HEIGHT 1024   /**< max framebuffer width */
  74
  75 #define TILE_SIZE 32
  76
  77
  78 /**
  79  * The low byte of a mailbox word contains the command opcode.
  80  * Remaining higher bytes are command specific.
  81  */
  82 #define CELL_CMD_OPCODE_MASK 0xff
  83
  84 #define CELL_CMD_EXIT                 1
  85 #define CELL_CMD_CLEAR_SURFACE        2
  86 #define CELL_CMD_FINISH               3
  87 #define CELL_CMD_RENDER               4
  88 #define CELL_CMD_BATCH                5
  89 #define CELL_CMD_RELEASE_VERTS        6
  90 #define CELL_CMD_STATE_FRAMEBUFFER   10
  91 #define CELL_CMD_STATE_FRAGMENT_OPS  11
  92 #define CELL_CMD_STATE_SAMPLER       12
  93 #define CELL_CMD_STATE_TEXTURE       13
  94 #define CELL_CMD_STATE_VERTEX_INFO   14
  95 #define CELL_CMD_STATE_VIEWPORT      15
  96 #define CELL_CMD_STATE_UNIFORMS      16
  97 #define CELL_CMD_STATE_VS_ARRAY_INFO 17
  98 #define CELL_CMD_STATE_BIND_VS       18
  99 #define CELL_CMD_STATE_FRAGMENT_PROGRAM 19
 100 #define CELL_CMD_STATE_ATTRIB_FETCH  20
 101 #define CELL_CMD_STATE_FS_CONSTANTS  21
 102 #define CELL_CMD_VS_EXECUTE          22
 103 #define CELL_CMD_FLUSH_BUFFER_RANGE  23
 104
 105 /** Command/batch buffers */
 106 #define CELL_NUM_BUFFERS 4
 107 #define CELL_BUFFER_SIZE (4*1024)  /**< 16KB would be the max */
 108
 109 #define CELL_BUFFER_STATUS_FREE 10
 110 #define CELL_BUFFER_STATUS_USED 20
 111
 112 /** Debug flags */
 113 #define CELL_DEBUG_CHECKER              (1 << 0)
 114 #define CELL_DEBUG_ASM                  (1 << 1)
 115 #define CELL_DEBUG_SYNC                 (1 << 2)
 116 #define CELL_DEBUG_FRAGMENT_OPS         (1 << 3)
 117 #define CELL_DEBUG_FRAGMENT_OP_FALLBACK (1 << 4)
 118 #define CELL_DEBUG_CMD                  (1 << 5)
 119
 120 /** Max instructions for doing per-fragment operations */
 121 #define SPU_MAX_FRAGMENT_OPS_INSTS 64
 122
 123
 124 /**
 125  * Command to specify per-fragment operations state and generated code.
 126  * Note that the dsa, blend, blend_color fields are really only needed
 127  * for the fallback/C per-pixel code.  They're not used when we generate
 128  * dynamic SPU fragment code (which is the normal case).
 129  */
 130 struct cell_command_fragment_ops
 131 {
 132    uint64_t opcode;      /**< CELL_CMD_STATE_FRAGMENT_OPS */
 133    struct pipe_depth_stencil_alpha_state dsa;
 134    struct pipe_blend_state blend;
 135    struct pipe_blend_color blend_color;
 136    unsigned code[SPU_MAX_FRAGMENT_OPS_INSTS];
 137 };
 138
 139
 140 /** Max instructions for fragment programs */
 141 #define SPU_MAX_FRAGMENT_PROGRAM_INSTS 512
 142
 143 /**
 144  * Command to send a fragment program to SPUs.
 145  */
 146 struct cell_command_fragment_program
 147 {
 148    uint64_t opcode;      /**< CELL_CMD_STATE_FRAGMENT_PROGRAM */
 149    uint num_inst;        /**< Number of instructions */
 150    unsigned code[SPU_MAX_FRAGMENT_PROGRAM_INSTS];
 151 };
 152
 153
 154 /**
 155  * Tell SPUs about the framebuffer size, location
 156  */
 157 struct cell_command_framebuffer
 158 {
 159    uint64_t opcode;     /**< CELL_CMD_FRAMEBUFFER */
 160    int width, height;
 161    void *color_start, *depth_start;
 162    enum pipe_format color_format, depth_format;
 163 };
 164
 165
 166 /**
 167  * Clear framebuffer to the given value/color.
 168  */
 169 struct cell_command_clear_surface
 170 {
 171    uint64_t opcode;     /**< CELL_CMD_CLEAR_SURFACE */
 172    uint surface; /**< Temporary: 0=color, 1=Z */
 173    uint value;
 174 };
 175
 176
 177 /**
 178  * Array info used by the vertex shader's vertex puller.
 179  */
 180 struct cell_array_info
 181 {
 182    uint64_t base;      /**< Base address of the 0th element. */
 183    uint attr;          /**< Attribute that this state is for. */
 184    uint pitch;         /**< Byte pitch from one entry to the next. */
 185    uint size;
 186    uint function_offset;
 187 };
 188
 189
 190 struct cell_attribute_fetch_code
 191 {
 192    uint64_t base;
 193    uint size;
 194 };
 195
 196
 197 struct cell_buffer_range
 198 {
 199    uint64_t base;
 200    unsigned size;
 201 };
 202
 203
 204 struct cell_shader_info
 205 {
 206    uint64_t declarations;
 207    uint64_t instructions;
 208    uint64_t  immediates;
 209
 210    unsigned num_outputs;
 211    unsigned num_declarations;
 212    unsigned num_instructions;
 213    unsigned num_immediates;
 214 };
 215
 216
 217 #define SPU_VERTS_PER_BATCH 64
 218 struct cell_command_vs
 219 {
 220    uint64_t opcode;       /**< CELL_CMD_VS_EXECUTE */
 221    uint64_t vOut[SPU_VERTS_PER_BATCH];
 222    unsigned num_elts;
 223    unsigned elts[SPU_VERTS_PER_BATCH];
 224    float plane[12][4];
 225    unsigned nr_planes;
 226    unsigned nr_attrs;
 227 };
 228
 229
 230 struct cell_command_render
 231 {
 232    uint64_t opcode;   /**< CELL_CMD_RENDER */
 233    uint prim_type;    /**< PIPE_PRIM_x */
 234    uint num_verts;
 235    uint vertex_size;  /**< bytes per vertex */
 236    uint num_indexes;
 237    uint vertex_buf;  /**< which cell->buffer[] contains the vertex data */
 238    float xmin, ymin, xmax, ymax;  /* XXX another dummy field */
 239    uint min_index;
 240    boolean inline_verts;
 241    uint front_winding; /* the rasterizer needs to be able to determine facing to apply front/back-facing stencil */
 242 };
 243
 244
 245 struct cell_command_release_verts
 246 {
 247    uint64_t opcode;         /**< CELL_CMD_RELEASE_VERTS */
 248    uint vertex_buf;    /**< in [0, CELL_NUM_BUFFERS-1] */
 249 };
 250
 251
 252 struct cell_command_sampler
 253 {
 254    uint64_t opcode;         /**< CELL_CMD_STATE_SAMPLER */
 255    uint unit;
 256    struct pipe_sampler_state state;
 257 };
 258
 259
 260 struct cell_command_texture
 261 {
 262    uint64_t opcode;     /**< CELL_CMD_STATE_TEXTURE */
 263    uint target;         /**< PIPE_TEXTURE_x */
 264    uint unit;
 265    void *start[CELL_MAX_TEXTURE_LEVELS];   /**< Address in main memory */
 266    ushort width[CELL_MAX_TEXTURE_LEVELS];
 267    ushort height[CELL_MAX_TEXTURE_LEVELS];
 268    ushort depth[CELL_MAX_TEXTURE_LEVELS];
 269 };
 270
 271
 272 #define MAX_SPU_FUNCTIONS 12
 273 /**
 274  * Used to tell the PPU about the address of particular functions in the
 275  * SPU's address space.
 276  */
 277 struct cell_spu_function_info
 278 {
 279    uint num;
 280    char names[MAX_SPU_FUNCTIONS][16];
 281    uint addrs[MAX_SPU_FUNCTIONS];
 282    char pad[12];   /**< Pad struct to multiple of 16 bytes (256 currently) */
 283 };
 284
 285
 286 /** This is the object passed to spe_create_thread() */
 287 struct cell_init_info
 288 {
 289    unsigned id;
 290    unsigned num_spus;
 291    unsigned debug_flags;  /**< mask of CELL_DEBUG_x flags */
 292
 293    /** Buffers for command batches, vertex/index data */
 294    ubyte *buffers[CELL_NUM_BUFFERS];
 295    uint *buffer_status;  /**< points at cell_context->buffer_status */
 296
 297    struct cell_spu_function_info *spu_functions;
 298 } ALIGN16_ATTRIB;
 299
 300
 301 #endif /* CELL_COMMON_H */