| /* |
| * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com> |
| * |
| * 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 |
| * on 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 |
| * THE AUTHOR(S) AND/OR THEIR 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 "radeon_r300.h" |
| #include "radeon_buffer.h" |
| |
| #include "radeon_bo_gem.h" |
| #include "radeon_cs_gem.h" |
| #include "state_tracker/drm_api.h" |
| |
| static struct r300_winsys_buffer * |
| radeon_r300_winsys_buffer_create(struct r300_winsys_screen *rws, |
| unsigned alignment, |
| unsigned usage, |
| unsigned size) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| struct pb_desc desc; |
| struct pb_manager *provider; |
| struct pb_buffer *buffer; |
| |
| memset(&desc, 0, sizeof(desc)); |
| desc.alignment = alignment; |
| desc.usage = usage; |
| |
| if (usage & PIPE_BIND_CONSTANT_BUFFER) |
| provider = ws->mman; |
| else if ((usage & PIPE_BIND_VERTEX_BUFFER) || |
| (usage & PIPE_BIND_INDEX_BUFFER)) |
| provider = ws->cman; |
| else |
| provider = ws->kman; |
| buffer = provider->create_buffer(provider, size, &desc); |
| if (!buffer) |
| return NULL; |
| |
| return radeon_libdrm_winsys_buffer(buffer); |
| } |
| |
| static void radeon_r300_winsys_buffer_destroy(struct r300_winsys_buffer *buf) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| |
| pb_destroy(_buf); |
| } |
| static void radeon_r300_winsys_buffer_set_tiling(struct r300_winsys_screen *rws, |
| struct r300_winsys_buffer *buf, |
| uint32_t pitch, |
| enum r300_buffer_tiling microtiled, |
| enum r300_buffer_tiling macrotiled) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| radeon_drm_bufmgr_set_tiling(_buf, microtiled, macrotiled, pitch); |
| } |
| |
| static void radeon_r300_winsys_buffer_get_tiling(struct r300_winsys_screen *rws, |
| struct r300_winsys_buffer *buf, |
| enum r300_buffer_tiling *microtiled, |
| enum r300_buffer_tiling *macrotiled) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| radeon_drm_bufmgr_get_tiling(_buf, microtiled, macrotiled); |
| } |
| |
| static void *radeon_r300_winsys_buffer_map(struct r300_winsys_screen *ws, |
| struct r300_winsys_buffer *buf, |
| unsigned usage) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| |
| return pb_map(_buf, usage); |
| } |
| |
| static void radeon_r300_winsys_buffer_unmap(struct r300_winsys_screen *ws, |
| struct r300_winsys_buffer *buf) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| |
| pb_unmap(_buf); |
| } |
| |
| static void radeon_r300_winsys_buffer_wait(struct r300_winsys_screen *ws, |
| struct r300_winsys_buffer *buf) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| radeon_drm_bufmgr_wait(_buf); |
| } |
| |
| static void radeon_r300_winsys_buffer_reference(struct r300_winsys_screen *rws, |
| struct r300_winsys_buffer **pdst, |
| struct r300_winsys_buffer *src) |
| { |
| struct pb_buffer *_src = radeon_pb_buffer(src); |
| struct pb_buffer *_dst = radeon_pb_buffer(*pdst); |
| |
| pb_reference(&_dst, _src); |
| |
| *pdst = radeon_libdrm_winsys_buffer(_dst); |
| } |
| |
| static boolean radeon_r300_winsys_is_buffer_referenced(struct r300_winsys_screen *rws, |
| struct r300_winsys_buffer *buf, |
| enum r300_reference_domain domain) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| |
| return radeon_drm_bufmgr_is_buffer_referenced(_buf, domain); |
| } |
| |
| static struct r300_winsys_buffer *radeon_r300_winsys_buffer_from_handle(struct r300_winsys_screen *rws, |
| struct pipe_screen *screen, |
| struct winsys_handle *whandle, |
| unsigned *stride) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| struct pb_buffer *_buf; |
| |
| _buf = radeon_drm_bufmgr_create_buffer_from_handle(ws->kman, whandle->handle); |
| *stride = whandle->stride; |
| return radeon_libdrm_winsys_buffer(_buf); |
| } |
| |
| static boolean radeon_r300_winsys_buffer_get_handle(struct r300_winsys_screen *rws, |
| struct r300_winsys_buffer *buffer, |
| unsigned stride, |
| struct winsys_handle *whandle) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buffer); |
| boolean ret; |
| ret = radeon_drm_bufmgr_get_handle(_buf, whandle); |
| if (ret) |
| whandle->stride = stride; |
| return ret; |
| } |
| |
| static void radeon_set_flush_cb(struct r300_winsys_screen *rws, |
| void (*flush_cb)(void *), |
| void *data) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| ws->flush_cb = flush_cb; |
| ws->flush_data = data; |
| radeon_cs_space_set_flush(ws->cs, flush_cb, data); |
| } |
| |
| static boolean radeon_add_buffer(struct r300_winsys_screen *rws, |
| struct r300_winsys_buffer *buf, |
| uint32_t rd, |
| uint32_t wd) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| |
| return radeon_drm_bufmgr_add_buffer(_buf, rd, wd); |
| } |
| |
| static boolean radeon_validate(struct r300_winsys_screen *rws) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| if (radeon_cs_space_check(ws->cs) < 0) { |
| return FALSE; |
| } |
| |
| /* Things are fine, we can proceed as normal. */ |
| return TRUE; |
| } |
| |
| static void radeon_get_cs_info(struct r300_winsys_screen *rws, |
| struct r300_cs_info *info) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| struct radeon_cs *cs = ws->cs; |
| |
| info->capacity = cs->ndw; |
| info->used = cs->cdw; |
| info->free = cs->ndw - cs->cdw; |
| } |
| |
| static void radeon_begin_cs(struct r300_winsys_screen *rws, |
| int size, |
| const char* file, |
| const char* function, |
| int line) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| radeon_cs_begin(ws->cs, size, file, function, line); |
| } |
| |
| static void radeon_write_cs_dword(struct r300_winsys_screen *rws, |
| uint32_t dword) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| radeon_cs_write_dword(ws->cs, dword); |
| } |
| |
| static void radeon_write_cs_table(struct r300_winsys_screen *rws, |
| const void *table, unsigned count) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| radeon_cs_write_table(ws->cs, table, count); |
| } |
| |
| static void radeon_write_cs_reloc(struct r300_winsys_screen *rws, |
| struct r300_winsys_buffer *buf, |
| uint32_t rd, |
| uint32_t wd, |
| uint32_t flags) |
| { |
| struct pb_buffer *_buf = radeon_pb_buffer(buf); |
| radeon_drm_bufmgr_write_reloc(_buf, rd, wd, flags); |
| } |
| |
| static void radeon_reset_bos(struct r300_winsys_screen *rws) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| radeon_cs_space_reset_bos(ws->cs); |
| } |
| |
| static void radeon_end_cs(struct r300_winsys_screen *rws, |
| const char* file, |
| const char* function, |
| int line) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| radeon_cs_end(ws->cs, file, function, line); |
| } |
| |
| static void radeon_flush_cs(struct r300_winsys_screen *rws) |
| { |
| struct radeon_libdrm_winsys *ws = radeon_winsys_screen(rws); |
| int retval; |
| |
| /* Don't flush a zero-sized CS. */ |
| if (!ws->cs->cdw) { |
| return; |
| } |
| |
| radeon_drm_bufmgr_flush_maps(ws->kman); |
| /* Emit the CS. */ |
| retval = radeon_cs_emit(ws->cs); |
| if (retval) { |
| debug_printf("radeon: Bad CS, dumping...\n"); |
| radeon_cs_print(ws->cs, stderr); |
| } |
| |
| /* Reset CS. |
| * Someday, when we care about performance, we should really find a way |
| * to rotate between two or three CS objects so that the GPU can be |
| * spinning through one CS while another one is being filled. */ |
| radeon_cs_erase(ws->cs); |
| } |
| |
| static uint32_t radeon_get_value(struct r300_winsys_screen *rws, |
| enum r300_value_id id) |
| { |
| struct radeon_libdrm_winsys *ws = (struct radeon_libdrm_winsys *)rws; |
| |
| switch(id) { |
| case R300_VID_PCI_ID: |
| return ws->pci_id; |
| case R300_VID_GB_PIPES: |
| return ws->gb_pipes; |
| case R300_VID_Z_PIPES: |
| return ws->z_pipes; |
| case R300_VID_SQUARE_TILING_SUPPORT: |
| return ws->squaretiling; |
| case R300_VID_DRM_2_3_0: |
| return ws->drm_2_3_0; |
| } |
| return 0; |
| } |
| |
| static void |
| radeon_winsys_destroy(struct r300_winsys_screen *rws) |
| { |
| struct radeon_libdrm_winsys *ws = (struct radeon_libdrm_winsys *)rws; |
| radeon_cs_destroy(ws->cs); |
| |
| ws->cman->destroy(ws->cman); |
| ws->kman->destroy(ws->kman); |
| ws->mman->destroy(ws->mman); |
| |
| radeon_bo_manager_gem_dtor(ws->bom); |
| radeon_cs_manager_gem_dtor(ws->csm); |
| } |
| |
| boolean |
| radeon_setup_winsys(int fd, struct radeon_libdrm_winsys* ws) |
| { |
| |
| ws->csm = radeon_cs_manager_gem_ctor(fd); |
| if (!ws->csm) |
| goto fail; |
| ws->bom = radeon_bo_manager_gem_ctor(fd); |
| if (!ws->bom) |
| goto fail; |
| ws->kman = radeon_drm_bufmgr_create(ws); |
| if (!ws->kman) |
| goto fail; |
| |
| ws->cman = pb_cache_manager_create(ws->kman, 100000); |
| if (!ws->cman) |
| goto fail; |
| |
| ws->mman = pb_malloc_bufmgr_create(); |
| if (!ws->mman) |
| goto fail; |
| |
| /* Size limit on IBs is 64 kibibytes. */ |
| ws->cs = radeon_cs_create(ws->csm, 1024 * 64 / 4); |
| if (!ws->cs) |
| goto fail; |
| radeon_cs_set_limit(ws->cs, |
| RADEON_GEM_DOMAIN_GTT, ws->gart_size); |
| radeon_cs_set_limit(ws->cs, |
| RADEON_GEM_DOMAIN_VRAM, ws->vram_size); |
| |
| ws->base.add_buffer = radeon_add_buffer; |
| ws->base.validate = radeon_validate; |
| ws->base.destroy = radeon_winsys_destroy; |
| ws->base.get_cs_info = radeon_get_cs_info; |
| ws->base.begin_cs = radeon_begin_cs; |
| ws->base.write_cs_dword = radeon_write_cs_dword; |
| ws->base.write_cs_table = radeon_write_cs_table; |
| ws->base.write_cs_reloc = radeon_write_cs_reloc; |
| ws->base.end_cs = radeon_end_cs; |
| ws->base.flush_cs = radeon_flush_cs; |
| ws->base.reset_bos = radeon_reset_bos; |
| ws->base.set_flush_cb = radeon_set_flush_cb; |
| ws->base.get_value = radeon_get_value; |
| |
| ws->base.buffer_create = radeon_r300_winsys_buffer_create; |
| ws->base.buffer_destroy = radeon_r300_winsys_buffer_destroy; |
| ws->base.buffer_set_tiling = radeon_r300_winsys_buffer_set_tiling; |
| ws->base.buffer_get_tiling = radeon_r300_winsys_buffer_get_tiling; |
| ws->base.buffer_map = radeon_r300_winsys_buffer_map; |
| ws->base.buffer_unmap = radeon_r300_winsys_buffer_unmap; |
| ws->base.buffer_wait = radeon_r300_winsys_buffer_wait; |
| ws->base.buffer_reference = radeon_r300_winsys_buffer_reference; |
| ws->base.buffer_from_handle = radeon_r300_winsys_buffer_from_handle; |
| ws->base.buffer_get_handle = radeon_r300_winsys_buffer_get_handle; |
| ws->base.is_buffer_referenced = radeon_r300_winsys_is_buffer_referenced; |
| return TRUE; |
| |
| fail: |
| if (ws->csm) |
| radeon_cs_manager_gem_dtor(ws->csm); |
| |
| if (ws->bom) |
| radeon_bo_manager_gem_dtor(ws->bom); |
| |
| if (ws->cman) |
| ws->cman->destroy(ws->cman); |
| if (ws->kman) |
| ws->kman->destroy(ws->kman); |
| if (ws->mman) |
| ws->mman->destroy(ws->mman); |
| |
| if (ws->cs) |
| radeon_cs_destroy(ws->cs); |
| return FALSE; |
| } |