radeon_winsys.h revision fb8cf51eeb91413e761e0510d1f8c11b8cd0a7ac
1/* 2 * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com> 3 * Copyright 2010 Marek Olšák <maraeo@gmail.com> 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * on the rights to use, copy, modify, merge, publish, distribute, sub 9 * license, and/or sell copies of the Software, and to permit persons to whom 10 * the Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, 20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 22 * USE OR OTHER DEALINGS IN THE SOFTWARE. */ 23 24#ifndef RADEON_WINSYS_H 25#define RADEON_WINSYS_H 26 27/* The public winsys interface header for the radeon driver. */ 28 29/* R300 features in DRM. 30 * 31 * 2.6.0: 32 * - Hyper-Z 33 * - GB_Z_PEQ_CONFIG on rv350->r4xx 34 * - R500 FG_ALPHA_VALUE 35 * 36 * 2.8.0: 37 * - R500 US_FORMAT regs 38 * - R500 ARGB2101010 colorbuffer 39 * - CMask and AA regs 40 * - R16F/RG16F 41 */ 42 43#include "pipebuffer/pb_bufmgr.h" 44#include "pipe/p_defines.h" 45#include "pipe/p_state.h" 46 47#define RADEON_MAX_CMDBUF_DWORDS (16 * 1024) 48#define RADEON_FLUSH_ASYNC (1 << 0) 49 50/* Tiling flags. */ 51enum radeon_bo_layout { 52 RADEON_LAYOUT_LINEAR = 0, 53 RADEON_LAYOUT_TILED, 54 RADEON_LAYOUT_SQUARETILED, 55 56 RADEON_LAYOUT_UNKNOWN 57}; 58 59enum radeon_bo_domain { /* bitfield */ 60 RADEON_DOMAIN_GTT = 2, 61 RADEON_DOMAIN_VRAM = 4 62}; 63 64struct winsys_handle; 65struct radeon_winsys_cs_handle; /* for write_reloc etc. */ 66 67struct radeon_winsys_cs { 68 unsigned cdw; /* Number of used dwords. */ 69 uint32_t *buf; /* The command buffer. */ 70}; 71 72struct radeon_info { 73 uint32_t pci_id; 74 uint32_t gart_size; 75 uint32_t vram_size; 76 uint32_t fd; /* XXX transitional */ 77 78 uint32_t drm_major; /* version */ 79 uint32_t drm_minor; 80 uint32_t drm_patchlevel; 81 82 uint32_t r300_num_gb_pipes; 83 uint32_t r300_num_z_pipes; 84 85 uint32_t r600_num_backends; 86 uint32_t r600_clock_crystal_freq; 87 uint32_t r600_tiling_config; 88}; 89 90enum radeon_feature_id { 91 RADEON_FID_R300_HYPERZ_ACCESS, /* ZMask + HiZ */ 92 RADEON_FID_R300_CMASK_ACCESS, 93}; 94 95struct radeon_winsys { 96 /** 97 * Destroy this winsys. 98 * 99 * \param ws The winsys this function is called from. 100 */ 101 void (*destroy)(struct radeon_winsys *ws); 102 103 /** 104 * Query an info structure from winsys. 105 * 106 * \param ws The winsys this function is called from. 107 * \param info Return structure 108 */ 109 void (*query_info)(struct radeon_winsys *ws, 110 struct radeon_info *info); 111 112 /************************************************************************** 113 * Buffer management. Buffer attributes are mostly fixed over its lifetime. 114 * 115 * Remember that gallium gets to choose the interface it needs, and the 116 * window systems must then implement that interface (rather than the 117 * other way around...). 118 *************************************************************************/ 119 120 /** 121 * Create a buffer object. 122 * 123 * \param ws The winsys this function is called from. 124 * \param size The size to allocate. 125 * \param alignment An alignment of the buffer in memory. 126 * \param bind A bitmask of the PIPE_BIND_* flags. 127 * \param domain A bitmask of the RADEON_DOMAIN_* flags. 128 * \return The created buffer object. 129 */ 130 struct pb_buffer *(*buffer_create)(struct radeon_winsys *ws, 131 unsigned size, 132 unsigned alignment, 133 unsigned bind, 134 enum radeon_bo_domain domain); 135 136 struct radeon_winsys_cs_handle *(*buffer_get_cs_handle)( 137 struct pb_buffer *buf); 138 139 /** 140 * Map the entire data store of a buffer object into the client's address 141 * space. 142 * 143 * \param buf A winsys buffer object to map. 144 * \param cs A command stream to flush if the buffer is referenced by it. 145 * \param usage A bitmask of the PIPE_TRANSFER_* flags. 146 * \return The pointer at the beginning of the buffer. 147 */ 148 void *(*buffer_map)(struct pb_buffer *buf, 149 struct radeon_winsys_cs *cs, 150 enum pipe_transfer_usage usage); 151 152 /** 153 * Unmap a buffer object from the client's address space. 154 * 155 * \param buf A winsys buffer object to unmap. 156 */ 157 void (*buffer_unmap)(struct pb_buffer *buf); 158 159 /** 160 * Return TRUE if a buffer object is being used by the GPU. 161 * 162 * \param buf A winsys buffer object. 163 */ 164 boolean (*buffer_is_busy)(struct pb_buffer *buf); 165 166 /** 167 * Wait for a buffer object until it is not used by a GPU. This is 168 * equivalent to a fence placed after the last command using the buffer, 169 * and synchronizing to the fence. 170 * 171 * \param buf A winsys buffer object to wait for. 172 */ 173 void (*buffer_wait)(struct pb_buffer *buf); 174 175 /** 176 * Return tiling flags describing a memory layout of a buffer object. 177 * 178 * \param buf A winsys buffer object to get the flags from. 179 * \param macrotile A pointer to the return value of the microtile flag. 180 * \param microtile A pointer to the return value of the macrotile flag. 181 * 182 * \note microtile and macrotile are not bitmasks! 183 */ 184 void (*buffer_get_tiling)(struct pb_buffer *buf, 185 enum radeon_bo_layout *microtile, 186 enum radeon_bo_layout *macrotile); 187 188 /** 189 * Set tiling flags describing a memory layout of a buffer object. 190 * 191 * \param buf A winsys buffer object to set the flags for. 192 * \param cs A command stream to flush if the buffer is referenced by it. 193 * \param macrotile A macrotile flag. 194 * \param microtile A microtile flag. 195 * \param stride A stride of the buffer in bytes, for texturing. 196 * 197 * \note microtile and macrotile are not bitmasks! 198 */ 199 void (*buffer_set_tiling)(struct pb_buffer *buf, 200 struct radeon_winsys_cs *cs, 201 enum radeon_bo_layout microtile, 202 enum radeon_bo_layout macrotile, 203 unsigned stride); 204 205 /** 206 * Get a winsys buffer from a winsys handle. The internal structure 207 * of the handle is platform-specific and only a winsys should access it. 208 * 209 * \param ws The winsys this function is called from. 210 * \param whandle A winsys handle pointer as was received from a state 211 * tracker. 212 * \param stride The returned buffer stride in bytes. 213 * \param size The returned buffer size. 214 */ 215 struct pb_buffer *(*buffer_from_handle)(struct radeon_winsys *ws, 216 struct winsys_handle *whandle, 217 unsigned *stride, 218 unsigned *size); 219 220 /** 221 * Get a winsys handle from a winsys buffer. The internal structure 222 * of the handle is platform-specific and only a winsys should access it. 223 * 224 * \param buf A winsys buffer object to get the handle from. 225 * \param whandle A winsys handle pointer. 226 * \param stride A stride of the buffer in bytes, for texturing. 227 * \return TRUE on success. 228 */ 229 boolean (*buffer_get_handle)(struct pb_buffer *buf, 230 unsigned stride, 231 struct winsys_handle *whandle); 232 233 /************************************************************************** 234 * Command submission. 235 * 236 * Each pipe context should create its own command stream and submit 237 * commands independently of other contexts. 238 *************************************************************************/ 239 240 /** 241 * Create a command stream. 242 * 243 * \param ws The winsys this function is called from. 244 */ 245 struct radeon_winsys_cs *(*cs_create)(struct radeon_winsys *ws); 246 247 /** 248 * Destroy a command stream. 249 * 250 * \param cs A command stream to destroy. 251 */ 252 void (*cs_destroy)(struct radeon_winsys_cs *cs); 253 254 /** 255 * Add a new buffer relocation. Every relocation must first be added 256 * before it can be written. 257 * 258 * \param cs A command stream to add buffer for validation against. 259 * \param buf A winsys buffer to validate. 260 * \param rd A read domain containing a bitmask of the RADEON_DOMAIN_* flags. 261 * \param wd A write domain containing a bitmask of the RADEON_DOMAIN_* flags. 262 */ 263 void (*cs_add_reloc)(struct radeon_winsys_cs *cs, 264 struct radeon_winsys_cs_handle *buf, 265 enum radeon_bo_domain rd, 266 enum radeon_bo_domain wd); 267 268 /** 269 * Return TRUE if there is enough memory in VRAM and GTT for the relocs 270 * added so far. If the validation fails, all the relocations which have 271 * been added since the last call of cs_validate will be removed and 272 * the CS will be flushed (provided there are still any relocations). 273 * 274 * \param cs A command stream to validate. 275 */ 276 boolean (*cs_validate)(struct radeon_winsys_cs *cs); 277 278 /** 279 * Write a relocated dword to a command buffer. 280 * 281 * \param cs A command stream the relocation is written to. 282 * \param buf A winsys buffer to write the relocation for. 283 * \param rd A read domain containing a bitmask of the RADEON_DOMAIN_* flags. 284 * \param wd A write domain containing a bitmask of the RADEON_DOMAIN_* flags. 285 */ 286 void (*cs_write_reloc)(struct radeon_winsys_cs *cs, 287 struct radeon_winsys_cs_handle *buf); 288 289 /** 290 * Flush a command stream. 291 * 292 * \param cs A command stream to flush. 293 * \param flags, RADEON_FLUSH_ASYNC or 0. 294 */ 295 void (*cs_flush)(struct radeon_winsys_cs *cs, unsigned flags); 296 297 /** 298 * Set a flush callback which is called from winsys when flush is 299 * required. 300 * 301 * \param cs A command stream to set the callback for. 302 * \param flush A flush callback function associated with the command stream. 303 * \param user A user pointer that will be passed to the flush callback. 304 */ 305 void (*cs_set_flush)(struct radeon_winsys_cs *cs, 306 void (*flush)(void *ctx, unsigned flags), 307 void *ctx); 308 309 /** 310 * Return TRUE if a buffer is referenced by a command stream. 311 * 312 * \param cs A command stream. 313 * \param buf A winsys buffer. 314 */ 315 boolean (*cs_is_buffer_referenced)(struct radeon_winsys_cs *cs, 316 struct radeon_winsys_cs_handle *buf); 317 318 /** 319 * Request access to a feature for a command stream. 320 * 321 * \param cs A command stream. 322 * \param fid Feature ID, one of RADEON_FID_* 323 * \param enable Whether to enable or disable the feature. 324 */ 325 boolean (*cs_request_feature)(struct radeon_winsys_cs *cs, 326 enum radeon_feature_id fid, 327 boolean enable); 328}; 329 330#endif 331