Reviewed-by: Michel Dänzer <michel.daenzer@amd.com>tags/11.2-branchpoint
@@ -367,7 +367,7 @@ static void evergreen_emit_direct_dispatch( | |||
struct radeon_winsys_cs *cs = rctx->b.gfx.cs; | |||
struct r600_pipe_compute *shader = rctx->cs_shader_state.shader; | |||
unsigned num_waves; | |||
unsigned num_pipes = rctx->screen->b.info.r600_max_pipes; | |||
unsigned num_pipes = rctx->screen->b.info.r600_max_quad_pipes; | |||
unsigned wave_divisor = (16 * num_pipes); | |||
int group_size = 1; | |||
int grid_size = 1; |
@@ -3793,7 +3793,7 @@ void evergreen_setup_tess_constants(struct r600_context *rctx, const struct pipe | |||
unsigned output_patch0_offset, perpatch_output_offset, lds_size; | |||
uint32_t values[16]; | |||
unsigned num_waves; | |||
unsigned num_pipes = rctx->screen->b.info.r600_max_pipes; | |||
unsigned num_pipes = rctx->screen->b.info.r600_max_quad_pipes; | |||
unsigned wave_divisor = (16 * num_pipes); | |||
*num_patches = 1; |
@@ -420,10 +420,10 @@ static int r600_get_param(struct pipe_screen* pscreen, enum pipe_cap param) | |||
/* Timer queries, present when the clock frequency is non zero. */ | |||
case PIPE_CAP_QUERY_TIME_ELAPSED: | |||
return rscreen->b.info.r600_clock_crystal_freq != 0; | |||
return rscreen->b.info.clock_crystal_freq != 0; | |||
case PIPE_CAP_QUERY_TIMESTAMP: | |||
return rscreen->b.info.drm_minor >= 20 && | |||
rscreen->b.info.r600_clock_crystal_freq != 0; | |||
rscreen->b.info.clock_crystal_freq != 0; | |||
case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET: | |||
case PIPE_CAP_MIN_TEXEL_OFFSET: |
@@ -181,7 +181,7 @@ bool r600_init_resource(struct r600_common_screen *rscreen, | |||
old_buf = res->buf; | |||
res->buf = new_buf; /* should be atomic */ | |||
if (rscreen->info.r600_virtual_address) | |||
if (rscreen->info.has_virtual_memory) | |||
res->gpu_address = rscreen->ws->buffer_get_virtual_address(res->buf); | |||
else | |||
res->gpu_address = 0; | |||
@@ -511,7 +511,7 @@ r600_buffer_from_user_memory(struct pipe_screen *screen, | |||
return NULL; | |||
} | |||
if (rscreen->info.r600_virtual_address) | |||
if (rscreen->info.has_virtual_memory) | |||
rbuffer->gpu_address = | |||
ws->buffer_get_virtual_address(rbuffer->buf); | |||
else |
@@ -60,7 +60,7 @@ static inline void r600_emit_reloc(struct r600_common_context *rctx, | |||
enum radeon_bo_priority priority) | |||
{ | |||
struct radeon_winsys_cs *cs = ring->cs; | |||
bool has_vm = ((struct r600_common_screen*)rctx->b.screen)->info.r600_virtual_address; | |||
bool has_vm = ((struct r600_common_screen*)rctx->b.screen)->info.has_virtual_memory; | |||
unsigned reloc = radeon_add_to_buffer_list(rctx, ring, rbo, usage, priority); | |||
if (!has_vm) { |
@@ -271,7 +271,7 @@ bool r600_common_context_init(struct r600_common_context *rctx, | |||
rctx->chip_class = rscreen->chip_class; | |||
if (rscreen->chip_class >= CIK) | |||
rctx->max_db = MAX2(8, rscreen->info.r600_num_backends); | |||
rctx->max_db = MAX2(8, rscreen->info.num_render_backends); | |||
else if (rscreen->chip_class >= EVERGREEN) | |||
rctx->max_db = 8; | |||
else | |||
@@ -315,7 +315,7 @@ bool r600_common_context_init(struct r600_common_context *rctx, | |||
if (!rctx->ctx) | |||
return false; | |||
if (rscreen->info.r600_has_dma && !(rscreen->debug_flags & DBG_NO_ASYNC_DMA)) { | |||
if (rscreen->info.has_sdma && !(rscreen->debug_flags & DBG_NO_ASYNC_DMA)) { | |||
rctx->dma.cs = rctx->ws->cs_create(rctx->ctx, RING_DMA, | |||
r600_flush_dma_ring, | |||
rctx, NULL); | |||
@@ -720,7 +720,7 @@ static int r600_get_compute_param(struct pipe_screen *screen, | |||
case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY: | |||
if (ret) { | |||
uint32_t *max_clock_frequency = ret; | |||
*max_clock_frequency = rscreen->info.max_sclk; | |||
*max_clock_frequency = rscreen->info.max_shader_clock; | |||
} | |||
return sizeof(uint32_t); | |||
@@ -756,7 +756,7 @@ static uint64_t r600_get_timestamp(struct pipe_screen *screen) | |||
struct r600_common_screen *rscreen = (struct r600_common_screen*)screen; | |||
return 1000000 * rscreen->ws->query_value(rscreen->ws, RADEON_TIMESTAMP) / | |||
rscreen->info.r600_clock_crystal_freq; | |||
rscreen->info.clock_crystal_freq; | |||
} | |||
static void r600_fence_reference(struct pipe_screen *screen, | |||
@@ -990,27 +990,33 @@ bool r600_common_screen_init(struct r600_common_screen *rscreen, | |||
if (rscreen->debug_flags & DBG_INFO) { | |||
printf("pci_id = 0x%x\n", rscreen->info.pci_id); | |||
printf("family = %i\n", rscreen->info.family); | |||
printf("family = %i (%s)\n", rscreen->info.family, | |||
r600_get_chip_name(rscreen)); | |||
printf("chip_class = %i\n", rscreen->info.chip_class); | |||
printf("gart_size = %i MB\n", (int)(rscreen->info.gart_size >> 20)); | |||
printf("vram_size = %i MB\n", (int)(rscreen->info.vram_size >> 20)); | |||
printf("max_sclk = %i\n", rscreen->info.max_sclk); | |||
printf("gart_size = %i MB\n", (int)DIV_ROUND_UP(rscreen->info.gart_size, 1024*1024)); | |||
printf("vram_size = %i MB\n", (int)DIV_ROUND_UP(rscreen->info.vram_size, 1024*1024)); | |||
printf("has_virtual_memory = %i\n", rscreen->info.has_virtual_memory); | |||
printf("gfx_ib_pad_with_type2 = %i\n", rscreen->info.gfx_ib_pad_with_type2); | |||
printf("has_sdma = %i\n", rscreen->info.has_sdma); | |||
printf("has_uvd = %i\n", rscreen->info.has_uvd); | |||
printf("vce_fw_version = %i\n", rscreen->info.vce_fw_version); | |||
printf("vce_harvest_config = %i\n", rscreen->info.vce_harvest_config); | |||
printf("clock_crystal_freq = %i\n", rscreen->info.clock_crystal_freq); | |||
printf("drm = %i.%i.%i\n", rscreen->info.drm_major, | |||
rscreen->info.drm_minor, rscreen->info.drm_patchlevel); | |||
printf("has_userptr = %i\n", rscreen->info.has_userptr); | |||
printf("r600_max_quad_pipes = %i\n", rscreen->info.r600_max_quad_pipes); | |||
printf("max_shader_clock = %i\n", rscreen->info.max_shader_clock); | |||
printf("num_good_compute_units = %i\n", rscreen->info.num_good_compute_units); | |||
printf("max_se = %i\n", rscreen->info.max_se); | |||
printf("max_sh_per_se = %i\n", rscreen->info.max_sh_per_se); | |||
printf("drm = %i.%i.%i\n", rscreen->info.drm_major, | |||
rscreen->info.drm_minor, rscreen->info.drm_patchlevel); | |||
printf("has_uvd = %i\n", rscreen->info.has_uvd); | |||
printf("vce_fw_version = %i\n", rscreen->info.vce_fw_version); | |||
printf("r600_num_backends = %i\n", rscreen->info.r600_num_backends); | |||
printf("r600_clock_crystal_freq = %i\n", rscreen->info.r600_clock_crystal_freq); | |||
printf("r600_gb_backend_map = %i\n", rscreen->info.r600_gb_backend_map); | |||
printf("r600_gb_backend_map_valid = %i\n", rscreen->info.r600_gb_backend_map_valid); | |||
printf("r600_tiling_config = 0x%x\n", rscreen->info.r600_tiling_config); | |||
printf("r600_num_tile_pipes = %i\n", rscreen->info.r600_num_tile_pipes); | |||
printf("r600_max_pipes = %i\n", rscreen->info.r600_max_pipes); | |||
printf("r600_virtual_address = %i\n", rscreen->info.r600_virtual_address); | |||
printf("r600_has_dma = %i\n", rscreen->info.r600_has_dma); | |||
printf("r600_backend_map = %i\n", rscreen->info.r600_backend_map); | |||
printf("r600_backend_map_valid = %i\n", rscreen->info.r600_backend_map_valid); | |||
printf("num_render_backends = %i\n", rscreen->info.num_render_backends); | |||
printf("num_tile_pipes = %i\n", rscreen->info.num_tile_pipes); | |||
printf("si_tile_mode_array_valid = %i\n", rscreen->info.si_tile_mode_array_valid); | |||
printf("cik_macrotile_mode_array_valid = %i\n", rscreen->info.cik_macrotile_mode_array_valid); | |||
} |
@@ -174,7 +174,7 @@ static boolean r600_query_sw_get_result(struct r600_common_context *rctx, | |||
case PIPE_QUERY_TIMESTAMP_DISJOINT: | |||
/* Convert from cycles per millisecond to cycles per second (Hz). */ | |||
result->timestamp_disjoint.frequency = | |||
(uint64_t)rctx->screen->info.r600_clock_crystal_freq * 1000; | |||
(uint64_t)rctx->screen->info.clock_crystal_freq * 1000; | |||
result->timestamp_disjoint.disjoint = FALSE; | |||
return TRUE; | |||
case PIPE_QUERY_GPU_FINISHED: { | |||
@@ -191,7 +191,7 @@ static boolean r600_query_sw_get_result(struct r600_common_context *rctx, | |||
result->u32 = rctx->screen->info.num_good_compute_units; | |||
return TRUE; | |||
case R600_QUERY_GPIN_NUM_RB: | |||
result->u32 = rctx->screen->info.r600_num_backends; | |||
result->u32 = rctx->screen->info.num_render_backends; | |||
return TRUE; | |||
case R600_QUERY_GPIN_NUM_SPI: | |||
result->u32 = 1; /* all supported chips have one SPI per SE */ | |||
@@ -936,7 +936,7 @@ boolean r600_query_hw_get_result(struct r600_common_context *rctx, | |||
/* Convert the time to expected units. */ | |||
if (rquery->type == PIPE_QUERY_TIME_ELAPSED || | |||
rquery->type == PIPE_QUERY_TIMESTAMP) { | |||
result->u64 = (1000000 * result->u64) / rctx->screen->info.r600_clock_crystal_freq; | |||
result->u64 = (1000000 * result->u64) / rctx->screen->info.clock_crystal_freq; | |||
} | |||
return TRUE; | |||
} | |||
@@ -1049,13 +1049,13 @@ void r600_query_init_backend_mask(struct r600_common_context *ctx) | |||
struct radeon_winsys_cs *cs = ctx->gfx.cs; | |||
struct r600_resource *buffer; | |||
uint32_t *results; | |||
unsigned num_backends = ctx->screen->info.r600_num_backends; | |||
unsigned num_backends = ctx->screen->info.num_render_backends; | |||
unsigned i, mask = 0; | |||
/* if backend_map query is supported by the kernel */ | |||
if (ctx->screen->info.r600_backend_map_valid) { | |||
unsigned num_tile_pipes = ctx->screen->info.r600_num_tile_pipes; | |||
unsigned backend_map = ctx->screen->info.r600_backend_map; | |||
if (ctx->screen->info.r600_gb_backend_map_valid) { | |||
unsigned num_tile_pipes = ctx->screen->info.num_tile_pipes; | |||
unsigned backend_map = ctx->screen->info.r600_gb_backend_map; | |||
unsigned item_width, item_mask; | |||
if (ctx->chip_class >= EVERGREEN) { | |||
@@ -1263,7 +1263,7 @@ void r600_query_init(struct r600_common_context *rctx) | |||
rctx->b.get_query_result = r600_get_query_result; | |||
rctx->render_cond_atom.emit = r600_emit_query_predication; | |||
if (((struct r600_common_screen*)rctx->b.screen)->info.r600_num_backends > 0) | |||
if (((struct r600_common_screen*)rctx->b.screen)->info.num_render_backends > 0) | |||
rctx->b.render_condition = r600_render_condition; | |||
LIST_INITHEAD(&rctx->active_nontimer_queries); |
@@ -245,46 +245,48 @@ struct radeon_winsys_cs { | |||
}; | |||
struct radeon_info { | |||
/* Device info. */ | |||
uint32_t pci_id; | |||
enum radeon_family family; | |||
enum chip_class chip_class; | |||
uint64_t gart_size; | |||
uint64_t vram_size; | |||
uint32_t max_sclk; | |||
uint32_t num_good_compute_units; | |||
uint32_t max_se; | |||
uint32_t max_sh_per_se; | |||
boolean has_virtual_memory; | |||
bool gfx_ib_pad_with_type2; | |||
boolean has_sdma; | |||
boolean has_uvd; | |||
uint32_t vce_fw_version; | |||
uint32_t vce_harvest_config; | |||
uint32_t clock_crystal_freq; | |||
/* Kernel info. */ | |||
uint32_t drm_major; /* version */ | |||
uint32_t drm_minor; | |||
uint32_t drm_patchlevel; | |||
boolean has_uvd; | |||
uint32_t vce_fw_version; | |||
boolean has_userptr; | |||
bool gfx_ib_pad_with_type2; | |||
/* Shader cores. */ | |||
uint32_t r600_max_quad_pipes; /* wave size / 16 */ | |||
uint32_t max_shader_clock; | |||
uint32_t num_good_compute_units; | |||
uint32_t max_se; /* shader engines */ | |||
uint32_t max_sh_per_se; /* shader arrays per shader engine */ | |||
/* Render backends (color + depth blocks). */ | |||
uint32_t r300_num_gb_pipes; | |||
uint32_t r300_num_z_pipes; | |||
uint32_t r600_num_backends; | |||
uint32_t r600_clock_crystal_freq; | |||
uint32_t r600_gb_backend_map; /* R600 harvest config */ | |||
boolean r600_gb_backend_map_valid; | |||
uint32_t r600_tiling_config; | |||
uint32_t r600_num_tile_pipes; | |||
uint32_t r600_max_pipes; | |||
boolean r600_virtual_address; | |||
boolean r600_has_dma; | |||
uint32_t r600_backend_map; | |||
boolean r600_backend_map_valid; | |||
uint32_t num_render_backends; | |||
uint32_t num_tile_pipes; /* pipe count from PIPE_CONFIG */ | |||
uint32_t enabled_rb_mask; /* GCN harvest config */ | |||
/* Tile modes. */ | |||
boolean si_tile_mode_array_valid; | |||
uint32_t si_tile_mode_array[32]; | |||
uint32_t si_backend_enabled_mask; | |||
boolean cik_macrotile_mode_array_valid; | |||
uint32_t cik_macrotile_mode_array[16]; | |||
uint32_t vce_harvest_config; | |||
}; | |||
enum radeon_feature_id { |
@@ -410,7 +410,7 @@ static int si_get_param(struct pipe_screen* pscreen, enum pipe_cap param) | |||
/* Timer queries, present when the clock frequency is non zero. */ | |||
case PIPE_CAP_QUERY_TIMESTAMP: | |||
case PIPE_CAP_QUERY_TIME_ELAPSED: | |||
return sscreen->b.info.r600_clock_crystal_freq != 0; | |||
return sscreen->b.info.clock_crystal_freq != 0; | |||
case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET: | |||
case PIPE_CAP_MIN_TEXEL_OFFSET: |
@@ -189,14 +189,14 @@ unsigned cik_db_pipe_config(struct si_screen *sscreen, unsigned tile_mode) | |||
/* This is probably broken for a lot of chips, but it's only used | |||
* if the kernel cannot return the tile mode array for CIK. */ | |||
switch (sscreen->b.info.r600_num_tile_pipes) { | |||
switch (sscreen->b.info.num_tile_pipes) { | |||
case 16: | |||
return V_02803C_X_ADDR_SURF_P16_32X32_16X16; | |||
case 8: | |||
return V_02803C_X_ADDR_SURF_P8_32X32_16X16; | |||
case 4: | |||
default: | |||
if (sscreen->b.info.r600_num_backends == 4) | |||
if (sscreen->b.info.num_render_backends == 4) | |||
return V_02803C_X_ADDR_SURF_P4_16X16; | |||
else | |||
return V_02803C_X_ADDR_SURF_P4_8X16; | |||
@@ -3572,8 +3572,8 @@ si_write_harvested_raster_configs(struct si_context *sctx, | |||
{ | |||
unsigned sh_per_se = MAX2(sctx->screen->b.info.max_sh_per_se, 1); | |||
unsigned num_se = MAX2(sctx->screen->b.info.max_se, 1); | |||
unsigned rb_mask = sctx->screen->b.info.si_backend_enabled_mask; | |||
unsigned num_rb = MIN2(sctx->screen->b.info.r600_num_backends, 16); | |||
unsigned rb_mask = sctx->screen->b.info.enabled_rb_mask; | |||
unsigned num_rb = MIN2(sctx->screen->b.info.num_render_backends, 16); | |||
unsigned rb_per_pkr = MIN2(num_rb / num_se / sh_per_se, 2); | |||
unsigned rb_per_se = num_rb / num_se; | |||
unsigned se_mask[4]; | |||
@@ -3702,8 +3702,8 @@ si_write_harvested_raster_configs(struct si_context *sctx, | |||
static void si_init_config(struct si_context *sctx) | |||
{ | |||
struct si_screen *sscreen = sctx->screen; | |||
unsigned num_rb = MIN2(sctx->screen->b.info.r600_num_backends, 16); | |||
unsigned rb_mask = sctx->screen->b.info.si_backend_enabled_mask; | |||
unsigned num_rb = MIN2(sctx->screen->b.info.num_render_backends, 16); | |||
unsigned rb_mask = sctx->screen->b.info.enabled_rb_mask; | |||
unsigned raster_config, raster_config_1; | |||
uint64_t border_color_va = sctx->border_color_buffer->gpu_address; | |||
struct si_pm4_state *pm4 = CALLOC_STRUCT(si_pm4_state); |
@@ -251,20 +251,20 @@ static boolean do_winsys_init(struct amdgpu_winsys *ws) | |||
ws->info.gart_size = gtt.heap_size; | |||
ws->info.vram_size = vram.heap_size; | |||
/* convert the shader clock from KHz to MHz */ | |||
ws->info.max_sclk = ws->amdinfo.max_engine_clk / 1000; | |||
ws->info.max_shader_clock = ws->amdinfo.max_engine_clk / 1000; | |||
ws->info.max_se = ws->amdinfo.num_shader_engines; | |||
ws->info.max_sh_per_se = ws->amdinfo.num_shader_arrays_per_engine; | |||
ws->info.has_uvd = uvd.available_rings != 0; | |||
ws->info.vce_fw_version = | |||
vce.available_rings ? vce_version : 0; | |||
ws->info.has_userptr = TRUE; | |||
ws->info.r600_num_backends = ws->amdinfo.rb_pipes; | |||
ws->info.r600_clock_crystal_freq = ws->amdinfo.gpu_counter_freq; | |||
ws->info.num_render_backends = ws->amdinfo.rb_pipes; | |||
ws->info.clock_crystal_freq = ws->amdinfo.gpu_counter_freq; | |||
ws->info.r600_tiling_config = r600_get_gb_tiling_config(&ws->amdinfo); | |||
ws->info.r600_num_tile_pipes = cik_get_num_tile_pipes(&ws->amdinfo); | |||
ws->info.r600_max_pipes = ws->amdinfo.max_quad_shader_pipes; /* TODO: is this correct? */ | |||
ws->info.r600_virtual_address = TRUE; | |||
ws->info.r600_has_dma = dma.available_rings != 0; | |||
ws->info.num_tile_pipes = cik_get_num_tile_pipes(&ws->amdinfo); | |||
ws->info.r600_max_quad_pipes = ws->amdinfo.max_quad_shader_pipes; /* TODO: is this correct? */ | |||
ws->info.has_virtual_memory = TRUE; | |||
ws->info.has_sdma = dma.available_rings != 0; | |||
/* Get the number of good compute units. */ | |||
ws->info.num_good_compute_units = 0; | |||
@@ -276,7 +276,7 @@ static boolean do_winsys_init(struct amdgpu_winsys *ws) | |||
memcpy(ws->info.si_tile_mode_array, ws->amdinfo.gb_tile_mode, | |||
sizeof(ws->amdinfo.gb_tile_mode)); | |||
ws->info.si_tile_mode_array_valid = TRUE; | |||
ws->info.si_backend_enabled_mask = ws->amdinfo.enabled_rb_pipes_mask; | |||
ws->info.enabled_rb_mask = ws->amdinfo.enabled_rb_pipes_mask; | |||
memcpy(ws->info.cik_macrotile_mode_array, ws->amdinfo.gb_macro_tile_mode, | |||
sizeof(ws->amdinfo.gb_macro_tile_mode)); |
@@ -281,7 +281,7 @@ void radeon_bo_destroy(struct pb_buffer *_buf) | |||
if (bo->ptr) | |||
os_munmap(bo->ptr, bo->base.size); | |||
if (rws->info.r600_virtual_address) { | |||
if (rws->info.has_virtual_memory) { | |||
if (rws->va_unmap_working) { | |||
struct drm_radeon_gem_va va; | |||
@@ -552,7 +552,7 @@ static struct radeon_bo *radeon_create_bo(struct radeon_drm_winsys *rws, | |||
pipe_mutex_init(bo->map_mutex); | |||
pb_cache_init_entry(&rws->bo_cache, &bo->cache_entry, &bo->base); | |||
if (rws->info.r600_virtual_address) { | |||
if (rws->info.has_virtual_memory) { | |||
struct drm_radeon_gem_va va; | |||
bo->va = radeon_bomgr_find_va(rws, size, alignment); | |||
@@ -834,7 +834,7 @@ static struct pb_buffer *radeon_winsys_bo_from_ptr(struct radeon_winsys *rws, | |||
pipe_mutex_unlock(ws->bo_handles_mutex); | |||
if (ws->info.r600_virtual_address) { | |||
if (ws->info.has_virtual_memory) { | |||
struct drm_radeon_gem_va va; | |||
bo->va = radeon_bomgr_find_va(ws, bo->base.size, 1 << 20); | |||
@@ -966,7 +966,7 @@ done: | |||
if (stride) | |||
*stride = whandle->stride; | |||
if (ws->info.r600_virtual_address && !bo->va) { | |||
if (ws->info.has_virtual_memory && !bo->va) { | |||
struct drm_radeon_gem_va va; | |||
bo->va = radeon_bomgr_find_va(ws, bo->base.size, 1 << 20); |
@@ -283,7 +283,7 @@ static unsigned radeon_add_buffer(struct radeon_drm_cs *cs, | |||
* This doesn't have to be done if virtual memory is enabled, | |||
* because there is no offset patching with virtual memory. | |||
*/ | |||
if (cs->base.ring_type != RING_DMA || cs->ws->info.r600_virtual_address) { | |||
if (cs->base.ring_type != RING_DMA || cs->ws->info.has_virtual_memory) { | |||
return i; | |||
} | |||
} | |||
@@ -540,7 +540,7 @@ static void radeon_drm_cs_flush(struct radeon_winsys_cs *rcs, | |||
cs->cst->flags[0] = 0; | |||
cs->cst->flags[1] = RADEON_CS_RING_DMA; | |||
cs->cst->cs.num_chunks = 3; | |||
if (cs->ws->info.r600_virtual_address) { | |||
if (cs->ws->info.has_virtual_memory) { | |||
cs->cst->flags[0] |= RADEON_CS_USE_VM; | |||
} | |||
break; | |||
@@ -567,7 +567,7 @@ static void radeon_drm_cs_flush(struct radeon_winsys_cs *rcs, | |||
cs->cst->flags[0] |= RADEON_CS_KEEP_TILING_FLAGS; | |||
cs->cst->cs.num_chunks = 3; | |||
} | |||
if (cs->ws->info.r600_virtual_address) { | |||
if (cs->ws->info.has_virtual_memory) { | |||
cs->cst->flags[0] |= RADEON_CS_USE_VM; | |||
cs->cst->cs.num_chunks = 3; | |||
} |
@@ -298,10 +298,10 @@ static boolean do_winsys_init(struct radeon_drm_winsys *ws) | |||
} | |||
/* Check for dma */ | |||
ws->info.r600_has_dma = FALSE; | |||
ws->info.has_sdma = FALSE; | |||
/* DMA is disabled on R700. There is IB corruption and hangs. */ | |||
if (ws->info.chip_class >= EVERGREEN && ws->info.drm_minor >= 27) { | |||
ws->info.r600_has_dma = TRUE; | |||
ws->info.has_sdma = TRUE; | |||
} | |||
/* Check for UVD and VCE */ | |||
@@ -351,11 +351,11 @@ static boolean do_winsys_init(struct radeon_drm_winsys *ws) | |||
/* Get max clock frequency info and convert it to MHz */ | |||
radeon_get_drm_value(ws->fd, RADEON_INFO_MAX_SCLK, NULL, | |||
&ws->info.max_sclk); | |||
ws->info.max_sclk /= 1000; | |||
&ws->info.max_shader_clock); | |||
ws->info.max_shader_clock /= 1000; | |||
radeon_get_drm_value(ws->fd, RADEON_INFO_SI_BACKEND_ENABLED_MASK, NULL, | |||
&ws->info.si_backend_enabled_mask); | |||
&ws->info.enabled_rb_mask); | |||
ws->num_cpus = sysconf(_SC_NPROCESSORS_ONLN); | |||
@@ -375,48 +375,48 @@ static boolean do_winsys_init(struct radeon_drm_winsys *ws) | |||
if (ws->info.drm_minor >= 9 && | |||
!radeon_get_drm_value(ws->fd, RADEON_INFO_NUM_BACKENDS, | |||
"num backends", | |||
&ws->info.r600_num_backends)) | |||
&ws->info.num_render_backends)) | |||
return FALSE; | |||
/* get the GPU counter frequency, failure is not fatal */ | |||
radeon_get_drm_value(ws->fd, RADEON_INFO_CLOCK_CRYSTAL_FREQ, NULL, | |||
&ws->info.r600_clock_crystal_freq); | |||
&ws->info.clock_crystal_freq); | |||
radeon_get_drm_value(ws->fd, RADEON_INFO_TILING_CONFIG, NULL, | |||
&ws->info.r600_tiling_config); | |||
if (ws->info.drm_minor >= 11) { | |||
radeon_get_drm_value(ws->fd, RADEON_INFO_NUM_TILE_PIPES, NULL, | |||
&ws->info.r600_num_tile_pipes); | |||
&ws->info.num_tile_pipes); | |||
if (radeon_get_drm_value(ws->fd, RADEON_INFO_BACKEND_MAP, NULL, | |||
&ws->info.r600_backend_map)) | |||
ws->info.r600_backend_map_valid = TRUE; | |||
&ws->info.r600_gb_backend_map)) | |||
ws->info.r600_gb_backend_map_valid = TRUE; | |||
} | |||
ws->info.r600_virtual_address = FALSE; | |||
ws->info.has_virtual_memory = FALSE; | |||
if (ws->info.drm_minor >= 13) { | |||
uint32_t ib_vm_max_size; | |||
ws->info.r600_virtual_address = TRUE; | |||
ws->info.has_virtual_memory = TRUE; | |||
if (!radeon_get_drm_value(ws->fd, RADEON_INFO_VA_START, NULL, | |||
&ws->va_start)) | |||
ws->info.r600_virtual_address = FALSE; | |||
ws->info.has_virtual_memory = FALSE; | |||
if (!radeon_get_drm_value(ws->fd, RADEON_INFO_IB_VM_MAX_SIZE, NULL, | |||
&ib_vm_max_size)) | |||
ws->info.r600_virtual_address = FALSE; | |||
ws->info.has_virtual_memory = FALSE; | |||
radeon_get_drm_value(ws->fd, RADEON_INFO_VA_UNMAP_WORKING, NULL, | |||
&ws->va_unmap_working); | |||
} | |||
if (ws->gen == DRV_R600 && !debug_get_bool_option("RADEON_VA", FALSE)) | |||
ws->info.r600_virtual_address = FALSE; | |||
ws->info.has_virtual_memory = FALSE; | |||
} | |||
/* Get max pipes, this is only needed for compute shaders. All evergreen+ | |||
* chips have at least 2 pipes, so we use 2 as a default. */ | |||
ws->info.r600_max_pipes = 2; | |||
ws->info.r600_max_quad_pipes = 2; | |||
radeon_get_drm_value(ws->fd, RADEON_INFO_MAX_PIPES, NULL, | |||
&ws->info.r600_max_pipes); | |||
&ws->info.r600_max_quad_pipes); | |||
/* All GPUs have at least one compute unit */ | |||
ws->info.num_good_compute_units = 1; |