geemili
/
drm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

radeon: straighten out the API insanity. 

as Michel pointed out we are exposing too much info for these object
for this to be maintainable going forward.

This patch set minimises the exposed parts of the radeon_bo and
radeon_cs objects to the piece necessary for ddx/mesa to operate
at a decent speed.

The major problem is mesa contains a legacy BO/CS managers which we still
need to expose functionality to, and we really cannot change the API
until we can drop the non-KMS codepaths.

Signed-off-by: Dave Airlie <airlied@redhat.com>
main
Dave Airlie 2009-12-17 14:11:55 +10:00
parent f1660c2491
commit 125994ab30
12 changed files with 508 additions and 644 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
radeon/Makefile.am
View File

@ -38,7 +38,8 @@ libdrm_radeon_la_SOURCES = \
radeon_bo_gem.c \ radeon_bo_gem.c \
radeon_cs_gem.c \ radeon_cs_gem.c \
radeon_cs_space.c \ radeon_cs_space.c \
radeon_track.c radeon_bo.c \
radeon_cs.c
libdrm_radeonincludedir = ${includedir}/drm libdrm_radeonincludedir = ${includedir}/drm
libdrm_radeoninclude_HEADERS = \ libdrm_radeoninclude_HEADERS = \
@ -46,7 +47,8 @@ libdrm_radeoninclude_HEADERS = \
radeon_cs.h \ radeon_cs.h \
radeon_bo_gem.h \ radeon_bo_gem.h \
radeon_cs_gem.h \ radeon_cs_gem.h \
radeon_track.h radeon_bo_int.h \
radeon_cs_int.h
pkgconfigdir = @pkgconfigdir@ pkgconfigdir = @pkgconfigdir@
pkgconfig_DATA = libdrm_radeon.pc pkgconfig_DATA = libdrm_radeon.pc

110
radeon/radeon_bo.c Normal file
View File

@ -0,0 +1,110 @@
#include <radeon_bo.h>
#include <radeon_bo_int.h>
void radeon_bo_debug(struct radeon_bo *bo,
const char *op)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
fprintf(stderr, "%s %p 0x%08X 0x%08X 0x%08X\n",
op, bo, bo->handle, boi->size, boi->cref);
}
struct radeon_bo *radeon_bo_open(struct radeon_bo_manager *bom,
uint32_t handle,
uint32_t size,
uint32_t alignment,
uint32_t domains,
uint32_t flags)
{
struct radeon_bo *bo;
bo = bom->funcs->bo_open(bom, handle, size, alignment, domains, flags);
return bo;
}
void radeon_bo_ref(struct radeon_bo *bo)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
boi->cref++;
boi->bom->funcs->bo_ref(boi);
}
struct radeon_bo *radeon_bo_unref(struct radeon_bo *bo)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
boi->cref--;
return boi->bom->funcs->bo_unref(boi);
}
int radeon_bo_map(struct radeon_bo *bo, int write)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
return boi->bom->funcs->bo_map(boi, write);
}
int radeon_bo_unmap(struct radeon_bo *bo)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
return boi->bom->funcs->bo_unmap(boi);
}
int radeon_bo_wait(struct radeon_bo *bo)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
if (!boi->bom->funcs->bo_wait)
return 0;
return boi->bom->funcs->bo_wait(boi);
}
int radeon_bo_is_busy(struct radeon_bo *bo,
uint32_t *domain)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
return boi->bom->funcs->bo_is_busy(boi, domain);
}
int radeon_bo_set_tiling(struct radeon_bo *bo,
uint32_t tiling_flags, uint32_t pitch)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
return boi->bom->funcs->bo_set_tiling(boi, tiling_flags, pitch);
}
int radeon_bo_get_tiling(struct radeon_bo *bo,
uint32_t *tiling_flags, uint32_t *pitch)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
return boi->bom->funcs->bo_get_tiling(boi, tiling_flags, pitch);
}
int radeon_bo_is_static(struct radeon_bo *bo)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
if (boi->bom->funcs->bo_is_static)
return boi->bom->funcs->bo_is_static(boi);
return 0;
}
int radeon_bo_is_referenced_by_cs(struct radeon_bo *bo,
struct radeon_cs *cs)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
return boi->cref > 1;
}
uint32_t radeon_bo_get_handle(struct radeon_bo *bo)
{
return bo->handle;
}
uint32_t radeon_bo_get_src_domain(struct radeon_bo *bo)
{
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
uint32_t src_domain;
src_domain = boi->space_accounted & 0xffff;
if (!src_domain)
src_domain = boi->space_accounted >> 16;
return src_domain;
}

202
radeon/radeon_bo.h
View File

@ -32,7 +32,6 @@
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include "radeon_track.h"
/* bo object */ /* bo object */
#define RADEON_BO_FLAGS_MACRO_TILE 1 #define RADEON_BO_FLAGS_MACRO_TILE 1
@ -42,188 +41,35 @@ struct radeon_bo_manager;
struct radeon_cs; struct radeon_cs;
struct radeon_bo { struct radeon_bo {
uint32_t alignment; void *ptr;
uint32_t flags;
uint32_t handle; uint32_t handle;
uint32_t size; uint32_t size;
uint32_t domains;
uint32_t flags;
unsigned cref;
#ifdef RADEON_BO_TRACK
struct radeon_track *track;
#endif
void *ptr;
struct radeon_bo_manager *bom;
uint32_t space_accounted;
uint32_t referenced_in_cs;
}; };
/* bo functions */ struct radeon_bo_manager;
struct radeon_bo_funcs {
struct radeon_bo *(*bo_open)(struct radeon_bo_manager *bom,
uint32_t handle,
uint32_t size,
uint32_t alignment,
uint32_t domains,
uint32_t flags);
void (*bo_ref)(struct radeon_bo *bo);
struct radeon_bo *(*bo_unref)(struct radeon_bo *bo);
int (*bo_map)(struct radeon_bo *bo, int write);
int (*bo_unmap)(struct radeon_bo *bo);
int (*bo_wait)(struct radeon_bo *bo);
int (*bo_is_static)(struct radeon_bo *bo);
int (*bo_set_tiling)(struct radeon_bo *bo, uint32_t tiling_flags,
uint32_t pitch);
int (*bo_get_tiling)(struct radeon_bo *bo, uint32_t *tiling_flags,
uint32_t *pitch);
int (*bo_is_busy)(struct radeon_bo *bo, uint32_t *domain);
int (*bo_is_referenced_by_cs)(struct radeon_bo *bo, struct radeon_cs *cs);
};
struct radeon_bo_manager { void radeon_bo_debug(struct radeon_bo *bo,
struct radeon_bo_funcs *funcs; const char *op);
int fd;
struct radeon_tracker tracker;
};
static inline void _radeon_bo_debug(struct radeon_bo *bo, struct radeon_bo *radeon_bo_open(struct radeon_bo_manager *bom,
const char *op, uint32_t handle,
const char *file, uint32_t size,
const char *func, uint32_t alignment,
int line) uint32_t domains,
{ uint32_t flags);
fprintf(stderr, "%s %p 0x%08X 0x%08X 0x%08X [%s %s %d]\n",
op, bo, bo->handle, bo->size, bo->cref, file, func, line);
}
static inline struct radeon_bo *_radeon_bo_open(struct radeon_bo_manager *bom,
uint32_t handle,
uint32_t size,
uint32_t alignment,
uint32_t domains,
uint32_t flags,
const char *file,
const char *func,
int line)
{
struct radeon_bo *bo;
bo = bom->funcs->bo_open(bom, handle, size, alignment, domains, flags);
#ifdef RADEON_BO_TRACK
if (bo) {
bo->track = radeon_tracker_add_track(&bom->tracker, bo->handle);
radeon_track_add_event(bo->track, file, func, "open", line);
}
#endif
return bo;
}
static inline void _radeon_bo_ref(struct radeon_bo *bo,
const char *file,
const char *func,
int line)
{
bo->cref++;
#ifdef RADEON_BO_TRACK
radeon_track_add_event(bo->track, file, func, "ref", line);
#endif
bo->bom->funcs->bo_ref(bo);
}
static inline struct radeon_bo *_radeon_bo_unref(struct radeon_bo *bo,
const char *file,
const char *func,
int line)
{
bo->cref--;
#ifdef RADEON_BO_TRACK
radeon_track_add_event(bo->track, file, func, "unref", line);
if (bo->cref <= 0) {
radeon_tracker_remove_track(&bo->bom->tracker, bo->track);
bo->track = NULL;
}
#endif
return bo->bom->funcs->bo_unref(bo);
}
static inline int _radeon_bo_map(struct radeon_bo *bo,
int write,
const char *file,
const char *func,
int line)
{
return bo->bom->funcs->bo_map(bo, write);
}
static inline int _radeon_bo_unmap(struct radeon_bo *bo,
const char *file,
const char *func,
int line)
{
return bo->bom->funcs->bo_unmap(bo);
}
static inline int _radeon_bo_wait(struct radeon_bo *bo,
const char *file,
const char *func,
int line)
{
return bo->bom->funcs->bo_wait(bo);
}
static inline int _radeon_bo_is_busy(struct radeon_bo *bo,
uint32_t *domain,
const char *file,
const char *func,
int line)
{
return bo->bom->funcs->bo_is_busy(bo, domain);
}
static inline int radeon_bo_set_tiling(struct radeon_bo *bo,
uint32_t tiling_flags, uint32_t pitch)
{
return bo->bom->funcs->bo_set_tiling(bo, tiling_flags, pitch);
}
static inline int radeon_bo_get_tiling(struct radeon_bo *bo,
uint32_t *tiling_flags, uint32_t *pitch)
{
return bo->bom->funcs->bo_get_tiling(bo, tiling_flags, pitch);
}
static inline int radeon_bo_is_static(struct radeon_bo *bo)
{
if (bo->bom->funcs->bo_is_static)
return bo->bom->funcs->bo_is_static(bo);
return 0;
}
static inline int _radeon_bo_is_referenced_by_cs(struct radeon_bo *bo,
struct radeon_cs *cs,
const char *file,
const char *func,
unsigned line)
{
return bo->cref > 1;
}
#define radeon_bo_open(bom, h, s, a, d, f)\
_radeon_bo_open(bom, h, s, a, d, f, __FILE__, __FUNCTION__, __LINE__)
#define radeon_bo_ref(bo)\
_radeon_bo_ref(bo, __FILE__, __FUNCTION__, __LINE__)
#define radeon_bo_unref(bo)\
_radeon_bo_unref(bo, __FILE__, __FUNCTION__, __LINE__)
#define radeon_bo_map(bo, w)\
_radeon_bo_map(bo, w, __FILE__, __FUNCTION__, __LINE__)
#define radeon_bo_unmap(bo)\
_radeon_bo_unmap(bo, __FILE__, __FUNCTION__, __LINE__)
#define radeon_bo_debug(bo, opcode)\
_radeon_bo_debug(bo, opcode, __FILE__, __FUNCTION__, __LINE__)
#define radeon_bo_wait(bo) \
_radeon_bo_wait(bo, __FILE__, __func__, __LINE__)
#define radeon_bo_is_busy(bo, domain) \
_radeon_bo_is_busy(bo, domain, __FILE__, __func__, __LINE__)
#define radeon_bo_is_referenced_by_cs(bo, cs) \
_radeon_bo_is_referenced_by_cs(bo, cs, __FILE__, __FUNCTION__, __LINE__)
void radeon_bo_ref(struct radeon_bo *bo);
struct radeon_bo *radeon_bo_unref(struct radeon_bo *bo);
int radeon_bo_map(struct radeon_bo *bo, int write);
int radeon_bo_unmap(struct radeon_bo *bo);
int radeon_bo_wait(struct radeon_bo *bo);
int radeon_bo_is_busy(struct radeon_bo *bo, uint32_t *domain);
int radeon_bo_set_tiling(struct radeon_bo *bo, uint32_t tiling_flags, uint32_t pitch);
int radeon_bo_get_tiling(struct radeon_bo *bo, uint32_t *tiling_flags, uint32_t *pitch);
int radeon_bo_is_static(struct radeon_bo *bo);
int radeon_bo_is_referenced_by_cs(struct radeon_bo *bo,
struct radeon_cs *cs);
uint32_t radeon_bo_get_handle(struct radeon_bo *bo);
uint32_t radeon_bo_get_src_domain(struct radeon_bo *bo);
#endif #endif

87
radeon/radeon_bo_gem.c
View File

@ -42,10 +42,11 @@
#include "drm.h" #include "drm.h"
#include "radeon_drm.h" #include "radeon_drm.h"
#include "radeon_bo.h" #include "radeon_bo.h"
#include "radeon_bo_int.h"
#include "radeon_bo_gem.h" #include "radeon_bo_gem.h"
struct radeon_bo_gem { struct radeon_bo_gem {
struct radeon_bo base; struct radeon_bo_int base;
uint32_t name; uint32_t name;
int map_count; int map_count;
void *priv_ptr; void *priv_ptr;
@ -55,7 +56,7 @@ struct bo_manager_gem {
struct radeon_bo_manager base; struct radeon_bo_manager base;
}; };
static int bo_wait(struct radeon_bo *bo); static int bo_wait(struct radeon_bo_int *boi);
static struct radeon_bo *bo_open(struct radeon_bo_manager *bom, static struct radeon_bo *bo_open(struct radeon_bo_manager *bom,
uint32_t handle, uint32_t handle,
@ -117,39 +118,39 @@ static struct radeon_bo *bo_open(struct radeon_bo_manager *bom,
return (struct radeon_bo*)bo; return (struct radeon_bo*)bo;
} }
static void bo_ref(struct radeon_bo *bo) static void bo_ref(struct radeon_bo_int *boi)
{ {
} }
static struct radeon_bo *bo_unref(struct radeon_bo *bo) static struct radeon_bo *bo_unref(struct radeon_bo_int *boi)
{ {
struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)bo; struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)boi;
struct drm_gem_close args; struct drm_gem_close args;
if (bo == NULL) { if (boi == NULL) {
return NULL; return NULL;
} }
if (bo->cref) { if (boi->cref) {
return bo; return (struct radeon_bo *)boi;
} }
if (bo_gem->priv_ptr) { if (bo_gem->priv_ptr) {
munmap(bo_gem->priv_ptr, bo->size); munmap(bo_gem->priv_ptr, boi->size);
} }
/* Zero out args to make valgrind happy */ /* Zero out args to make valgrind happy */
memset(&args, 0, sizeof(args)); memset(&args, 0, sizeof(args));
/* close object */ /* close object */
args.handle = bo->handle; args.handle = boi->handle;
drmIoctl(bo->bom->fd, DRM_IOCTL_GEM_CLOSE, &args); drmIoctl(boi->bom->fd, DRM_IOCTL_GEM_CLOSE, &args);
memset(bo_gem, 0, sizeof(struct radeon_bo_gem)); memset(bo_gem, 0, sizeof(struct radeon_bo_gem));
free(bo_gem); free(bo_gem);
return NULL; return NULL;
} }
static int bo_map(struct radeon_bo *bo, int write) static int bo_map(struct radeon_bo_int *boi, int write)
{ {
struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)bo; struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)boi;
struct drm_radeon_gem_mmap args; struct drm_radeon_gem_mmap args;
int r; int r;
void *ptr; void *ptr;
@ -161,102 +162,102 @@ static int bo_map(struct radeon_bo *bo, int write)
goto wait; goto wait;
} }
bo->ptr = NULL; boi->ptr = NULL;
/* Zero out args to make valgrind happy */ /* Zero out args to make valgrind happy */
memset(&args, 0, sizeof(args)); memset(&args, 0, sizeof(args));
args.handle = bo->handle; args.handle = boi->handle;
args.offset = 0; args.offset = 0;
args.size = (uint64_t)bo->size; args.size = (uint64_t)boi->size;
r = drmCommandWriteRead(bo->bom->fd, r = drmCommandWriteRead(boi->bom->fd,
DRM_RADEON_GEM_MMAP, DRM_RADEON_GEM_MMAP,
&args, &args,
sizeof(args)); sizeof(args));
if (r) { if (r) {
fprintf(stderr, "error mapping %p 0x%08X (error = %d)\n", fprintf(stderr, "error mapping %p 0x%08X (error = %d)\n",
bo, bo->handle, r); boi, boi->handle, r);
return r; return r;
} }
ptr = mmap(0, args.size, PROT_READ|PROT_WRITE, MAP_SHARED, bo->bom->fd, args.addr_ptr); ptr = mmap(0, args.size, PROT_READ|PROT_WRITE, MAP_SHARED, boi->bom->fd, args.addr_ptr);
if (ptr == MAP_FAILED) if (ptr == MAP_FAILED)
return -errno; return -errno;
bo_gem->priv_ptr = ptr; bo_gem->priv_ptr = ptr;
wait: wait:
bo->ptr = bo_gem->priv_ptr; boi->ptr = bo_gem->priv_ptr;
r = bo_wait(bo); r = bo_wait(boi);
if (r) if (r)
return r; return r;
return 0; return 0;
} }
static int bo_unmap(struct radeon_bo *bo) static int bo_unmap(struct radeon_bo_int *boi)
{ {
struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)bo; struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)boi;
if (--bo_gem->map_count > 0) { if (--bo_gem->map_count > 0) {
return 0; return 0;
} }
//munmap(bo->ptr, bo->size); //munmap(bo->ptr, bo->size);
bo->ptr = NULL; boi->ptr = NULL;
return 0; return 0;
} }
static int bo_wait(struct radeon_bo *bo) static int bo_wait(struct radeon_bo_int *boi)
{ {
struct drm_radeon_gem_wait_idle args; struct drm_radeon_gem_wait_idle args;
int ret; int ret;
/* Zero out args to make valgrind happy */ /* Zero out args to make valgrind happy */
memset(&args, 0, sizeof(args)); memset(&args, 0, sizeof(args));
args.handle = bo->handle; args.handle = boi->handle;
do { do {
ret = drmCommandWriteRead(bo->bom->fd, DRM_RADEON_GEM_WAIT_IDLE, ret = drmCommandWriteRead(boi->bom->fd, DRM_RADEON_GEM_WAIT_IDLE,
&args, sizeof(args)); &args, sizeof(args));
} while (ret == -EBUSY); } while (ret == -EBUSY);
return ret; return ret;
} }
static int bo_is_busy(struct radeon_bo *bo, uint32_t *domain) static int bo_is_busy(struct radeon_bo_int *boi, uint32_t *domain)
{ {
struct drm_radeon_gem_busy args; struct drm_radeon_gem_busy args;
int ret; int ret;
args.handle = bo->handle; args.handle = boi->handle;
args.domain = 0; args.domain = 0;
ret = drmCommandWriteRead(bo->bom->fd, DRM_RADEON_GEM_BUSY, ret = drmCommandWriteRead(boi->bom->fd, DRM_RADEON_GEM_BUSY,
&args, sizeof(args)); &args, sizeof(args));
*domain = args.domain; *domain = args.domain;
return ret; return ret;
} }
static int bo_set_tiling(struct radeon_bo *bo, uint32_t tiling_flags, static int bo_set_tiling(struct radeon_bo_int *boi, uint32_t tiling_flags,
uint32_t pitch) uint32_t pitch)
{ {
struct drm_radeon_gem_set_tiling args; struct drm_radeon_gem_set_tiling args;
int r; int r;
args.handle = bo->handle; args.handle = boi->handle;
args.tiling_flags = tiling_flags; args.tiling_flags = tiling_flags;
args.pitch = pitch; args.pitch = pitch;
r = drmCommandWriteRead(bo->bom->fd, r = drmCommandWriteRead(boi->bom->fd,
DRM_RADEON_GEM_SET_TILING, DRM_RADEON_GEM_SET_TILING,
&args, &args,
sizeof(args)); sizeof(args));
return r; return r;
} }
static int bo_get_tiling(struct radeon_bo *bo, uint32_t *tiling_flags, static int bo_get_tiling(struct radeon_bo_int *boi, uint32_t *tiling_flags,
uint32_t *pitch) uint32_t *pitch)
{ {
struct drm_radeon_gem_set_tiling args; struct drm_radeon_gem_set_tiling args;
int r; int r;
args.handle = bo->handle; args.handle = boi->handle;
r = drmCommandWriteRead(bo->bom->fd, r = drmCommandWriteRead(boi->bom->fd,
DRM_RADEON_GEM_GET_TILING, DRM_RADEON_GEM_GET_TILING,
&args, &args,
sizeof(args)); sizeof(args));
@ -313,11 +314,12 @@ uint32_t radeon_gem_name_bo(struct radeon_bo *bo)
int radeon_gem_get_kernel_name(struct radeon_bo *bo, uint32_t *name) int radeon_gem_get_kernel_name(struct radeon_bo *bo, uint32_t *name)
{ {
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
struct drm_gem_flink flink; struct drm_gem_flink flink;
int r; int r;
flink.handle = bo->handle; flink.handle = bo->handle;
r = drmIoctl(bo->bom->fd, DRM_IOCTL_GEM_FLINK, &flink); r = drmIoctl(boi->bom->fd, DRM_IOCTL_GEM_FLINK, &flink);
if (r) { if (r) {
return r; return r;
} }
@ -327,6 +329,7 @@ int radeon_gem_get_kernel_name(struct radeon_bo *bo, uint32_t *name)
int radeon_gem_set_domain(struct radeon_bo *bo, uint32_t read_domains, uint32_t write_domain) int radeon_gem_set_domain(struct radeon_bo *bo, uint32_t read_domains, uint32_t write_domain)
{ {
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
struct drm_radeon_gem_set_domain args; struct drm_radeon_gem_set_domain args;
int r; int r;
@ -334,7 +337,7 @@ int radeon_gem_set_domain(struct radeon_bo *bo, uint32_t read_domains, uint32_t
args.read_domains = read_domains; args.read_domains = read_domains;
args.write_domain = write_domain; args.write_domain = write_domain;
r = drmCommandWriteRead(bo->bom->fd, r = drmCommandWriteRead(boi->bom->fd,
DRM_RADEON_GEM_SET_DOMAIN, DRM_RADEON_GEM_SET_DOMAIN,
&args, &args,
sizeof(args)); sizeof(args));

45
radeon/radeon_bo_int.h Normal file
View File

@ -0,0 +1,45 @@
#ifndef RADEON_BO_INT
#define RADEON_BO_INT
struct radeon_bo_manager {
struct radeon_bo_funcs *funcs;
int fd;
};
struct radeon_bo_int {
void *ptr;
uint32_t flags;
uint32_t handle;
uint32_t size;
/* private members */
uint32_t alignment;
uint32_t domains;
unsigned cref;
struct radeon_bo_manager *bom;
uint32_t space_accounted;
uint32_t referenced_in_cs;
};
/* bo functions */
struct radeon_bo_funcs {
struct radeon_bo *(*bo_open)(struct radeon_bo_manager *bom,
uint32_t handle,
uint32_t size,
uint32_t alignment,
uint32_t domains,
uint32_t flags);
void (*bo_ref)(struct radeon_bo_int *bo);
struct radeon_bo *(*bo_unref)(struct radeon_bo_int *bo);
int (*bo_map)(struct radeon_bo_int *bo, int write);
int (*bo_unmap)(struct radeon_bo_int *bo);
int (*bo_wait)(struct radeon_bo_int *bo);
int (*bo_is_static)(struct radeon_bo_int *bo);
int (*bo_set_tiling)(struct radeon_bo_int *bo, uint32_t tiling_flags,
uint32_t pitch);
int (*bo_get_tiling)(struct radeon_bo_int *bo, uint32_t *tiling_flags,
uint32_t *pitch);
int (*bo_is_busy)(struct radeon_bo_int *bo, uint32_t *domain);
int (*bo_is_referenced_by_cs)(struct radeon_bo_int *bo, struct radeon_cs *cs);
};
#endif

92
radeon/radeon_cs.c Normal file
View File

@ -0,0 +1,92 @@
#include <stdio.h>
#include "radeon_cs.h"
#include "radeon_cs_int.h"
struct radeon_cs *radeon_cs_create(struct radeon_cs_manager *csm,
uint32_t ndw)
{
struct radeon_cs_int *csi = csm->funcs->cs_create(csm, ndw);
return (struct radeon_cs *)csi;
}
int radeon_cs_write_reloc(struct radeon_cs *cs,
struct radeon_bo *bo,
uint32_t read_domain,
uint32_t write_domain,
uint32_t flags)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return csi->csm->funcs->cs_write_reloc(csi,
bo,
read_domain,
write_domain,
flags);
}
int radeon_cs_begin(struct radeon_cs *cs,
uint32_t ndw,
const char *file,
const char *func,
int line)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return csi->csm->funcs->cs_begin(csi, ndw, file, func, line);
}
int radeon_cs_end(struct radeon_cs *cs,
const char *file,
const char *func,
int line)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return csi->csm->funcs->cs_end(csi, file, func, line);
}
int radeon_cs_emit(struct radeon_cs *cs)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return csi->csm->funcs->cs_emit(csi);
}
int radeon_cs_destroy(struct radeon_cs *cs)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return csi->csm->funcs->cs_destroy(csi);
}
int radeon_cs_erase(struct radeon_cs *cs)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return csi->csm->funcs->cs_erase(csi);
}
int radeon_cs_need_flush(struct radeon_cs *cs)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return csi->csm->funcs->cs_need_flush(csi);
}
void radeon_cs_print(struct radeon_cs *cs, FILE *file)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
csi->csm->funcs->cs_print(csi, file);
}
void radeon_cs_set_limit(struct radeon_cs *cs, uint32_t domain, uint32_t limit)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
if (domain == RADEON_GEM_DOMAIN_VRAM)
csi->csm->vram_limit = limit;
else
csi->csm->gart_limit = limit;
}
void radeon_cs_space_set_flush(struct radeon_cs *cs, void (*fn)(void *), void *data)
{
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
csi->space_flush_fn = fn;
csi->space_flush_data = data;
}

213
radeon/radeon_cs.h
View File

@ -50,172 +50,41 @@ struct radeon_cs_reloc {
#define RADEON_CS_SPACE_OP_TO_BIG 1 #define RADEON_CS_SPACE_OP_TO_BIG 1
#define RADEON_CS_SPACE_FLUSH 2 #define RADEON_CS_SPACE_FLUSH 2
struct radeon_cs_space_check { struct radeon_cs {
struct radeon_bo *bo; uint32_t *packets;
uint32_t read_domains; unsigned cdw;
uint32_t write_domain; unsigned ndw;
uint32_t new_accounted; unsigned section_ndw;
unsigned section_cdw;
}; };
#define MAX_SPACE_BOS (32) #define MAX_SPACE_BOS (32)
struct radeon_cs_manager; struct radeon_cs_manager;
struct radeon_cs { extern struct radeon_cs *radeon_cs_create(struct radeon_cs_manager *csm,
struct radeon_cs_manager *csm; uint32_t ndw);
void *relocs;
uint32_t *packets;
unsigned crelocs;
unsigned relocs_total_size;
unsigned cdw;
unsigned ndw;
int section;
unsigned section_ndw;
unsigned section_cdw;
const char *section_file;
const char *section_func;
int section_line;
struct radeon_cs_space_check bos[MAX_SPACE_BOS];
int bo_count;
void (*space_flush_fn)(void *);
void *space_flush_data;
};
/* cs functions */
struct radeon_cs_funcs {
struct radeon_cs *(*cs_create)(struct radeon_cs_manager *csm,
uint32_t ndw);
int (*cs_write_reloc)(struct radeon_cs *cs,
struct radeon_bo *bo,
uint32_t read_domain,
uint32_t write_domain,
uint32_t flags);
int (*cs_begin)(struct radeon_cs *cs,
uint32_t ndw,
const char *file,
const char *func,
int line);
int (*cs_end)(struct radeon_cs *cs,
const char *file,
const char *func,
int line);
int (*cs_emit)(struct radeon_cs *cs);
int (*cs_destroy)(struct radeon_cs *cs);
int (*cs_erase)(struct radeon_cs *cs);
int (*cs_need_flush)(struct radeon_cs *cs);
void (*cs_print)(struct radeon_cs *cs, FILE *file);
};
struct radeon_cs_manager {
struct radeon_cs_funcs *funcs;
int fd;
int32_t vram_limit, gart_limit;
int32_t vram_write_used, gart_write_used;
int32_t read_used;
};
static inline struct radeon_cs *radeon_cs_create(struct radeon_cs_manager *csm,
uint32_t ndw)
{
return csm->funcs->cs_create(csm, ndw);
}
static inline int radeon_cs_write_reloc(struct radeon_cs *cs,
struct radeon_bo *bo,
uint32_t read_domain,
uint32_t write_domain,
uint32_t flags)
{
return cs->csm->funcs->cs_write_reloc(cs,
bo,
read_domain,
write_domain,
flags);
}
static inline int radeon_cs_begin(struct radeon_cs *cs,
uint32_t ndw,
const char *file,
const char *func,
int line)
{
return cs->csm->funcs->cs_begin(cs, ndw, file, func, line);
}
static inline int radeon_cs_end(struct radeon_cs *cs,
const char *file,
const char *func,
int line)
{
return cs->csm->funcs->cs_end(cs, file, func, line);
}
static inline int radeon_cs_emit(struct radeon_cs *cs)
{
return cs->csm->funcs->cs_emit(cs);
}
static inline int radeon_cs_destroy(struct radeon_cs *cs)
{
return cs->csm->funcs->cs_destroy(cs);
}
static inline int radeon_cs_erase(struct radeon_cs *cs)
{
return cs->csm->funcs->cs_erase(cs);
}
static inline int radeon_cs_need_flush(struct radeon_cs *cs)
{
return cs->csm->funcs->cs_need_flush(cs);
}
static inline void radeon_cs_print(struct radeon_cs *cs, FILE *file)
{
cs->csm->funcs->cs_print(cs, file);
}
static inline void radeon_cs_set_limit(struct radeon_cs *cs, uint32_t domain, uint32_t limit)
{
if (domain == RADEON_GEM_DOMAIN_VRAM)
cs->csm->vram_limit = limit;
else
cs->csm->gart_limit = limit;
}
static inline void radeon_cs_write_dword(struct radeon_cs *cs, uint32_t dword)
{
cs->packets[cs->cdw++] = dword;
if (cs->section) {
cs->section_cdw++;
}
}
static inline void radeon_cs_write_qword(struct radeon_cs *cs, uint64_t qword)
{
memcpy(cs->packets + cs->cdw, &qword, sizeof(uint64_t));
cs->cdw += 2;
if (cs->section) {
cs->section_cdw += 2;
}
}
static inline void radeon_cs_write_table(struct radeon_cs *cs, void *data, uint32_t size)
{
memcpy(cs->packets + cs->cdw, data, size * 4);
cs->cdw += size;
if (cs->section) {
cs->section_cdw += size;
}
}
static inline void radeon_cs_space_set_flush(struct radeon_cs *cs, void (*fn)(void *), void *data)
{
cs->space_flush_fn = fn;
cs->space_flush_data = data;
}
extern int radeon_cs_begin(struct radeon_cs *cs,
uint32_t ndw,
const char *file,
const char *func, int line);
extern int radeon_cs_end(struct radeon_cs *cs,
const char *file,
const char *func,
int line);
extern int radeon_cs_emit(struct radeon_cs *cs);
extern int radeon_cs_destroy(struct radeon_cs *cs);
extern int radeon_cs_erase(struct radeon_cs *cs);
extern int radeon_cs_need_flush(struct radeon_cs *cs);
extern void radeon_cs_print(struct radeon_cs *cs, FILE *file);
extern void radeon_cs_set_limit(struct radeon_cs *cs, uint32_t domain, uint32_t limit);
extern void radeon_cs_space_set_flush(struct radeon_cs *cs, void (*fn)(void *), void *data);
extern int radeon_cs_write_reloc(struct radeon_cs *cs,
struct radeon_bo *bo,
uint32_t read_domain,
uint32_t write_domain,
uint32_t flags);
/* /*
* add a persistent BO to the list * add a persistent BO to the list
@ -243,4 +112,30 @@ int radeon_cs_space_check_with_bo(struct radeon_cs *cs,
uint32_t read_domains, uint32_t read_domains,
uint32_t write_domain); uint32_t write_domain);
static inline void radeon_cs_write_dword(struct radeon_cs *cs, uint32_t dword)
{
cs->packets[cs->cdw++] = dword;
if (cs->section_ndw) {
cs->section_cdw++;
}
}
static inline void radeon_cs_write_qword(struct radeon_cs *cs, uint64_t qword)
{
memcpy(cs->packets + cs->cdw, &qword, sizeof(uint64_t));
cs->cdw += 2;
if (cs->section_ndw) {
cs->section_cdw += 2;
}
}
static inline void radeon_cs_write_table(struct radeon_cs *cs,
void *data, uint32_t size)
{
memcpy(cs->packets + cs->cdw, data, size * 4);
cs->cdw += size;
if (cs->section_ndw) {
cs->section_cdw += size;
}
}
#endif #endif

60
radeon/radeon_cs_gem.c
View File

@ -35,6 +35,8 @@
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include "radeon_cs.h" #include "radeon_cs.h"
#include "radeon_cs_int.h"
#include "radeon_bo_int.h"
#include "radeon_cs_gem.h" #include "radeon_cs_gem.h"
#include "radeon_bo_gem.h" #include "radeon_bo_gem.h"
#include "drm.h" #include "drm.h"
@ -53,15 +55,15 @@ struct cs_reloc_gem {
#define RELOC_SIZE (sizeof(struct cs_reloc_gem) / sizeof(uint32_t)) #define RELOC_SIZE (sizeof(struct cs_reloc_gem) / sizeof(uint32_t))
struct cs_gem { struct cs_gem {
struct radeon_cs base; struct radeon_cs_int base;
struct drm_radeon_cs cs; struct drm_radeon_cs cs;
struct drm_radeon_cs_chunk chunks[2]; struct drm_radeon_cs_chunk chunks[2];
unsigned nrelocs; unsigned nrelocs;
uint32_t *relocs; uint32_t *relocs;
struct radeon_bo **relocs_bo; struct radeon_bo_int **relocs_bo;
}; };
static struct radeon_cs *cs_gem_create(struct radeon_cs_manager *csm, static struct radeon_cs_int *cs_gem_create(struct radeon_cs_manager *csm,
uint32_t ndw) uint32_t ndw)
{ {
struct cs_gem *csg; struct cs_gem *csg;
@ -84,7 +86,7 @@ static struct radeon_cs *cs_gem_create(struct radeon_cs_manager *csm,
csg->base.relocs_total_size = 0; csg->base.relocs_total_size = 0;
csg->base.crelocs = 0; csg->base.crelocs = 0;
csg->nrelocs = 4096 / (4 * 4) ; csg->nrelocs = 4096 / (4 * 4) ;
csg->relocs_bo = (struct radeon_bo**)calloc(1, csg->relocs_bo = (struct radeon_bo_int**)calloc(1,
csg->nrelocs*sizeof(void*)); csg->nrelocs*sizeof(void*));
if (csg->relocs_bo == NULL) { if (csg->relocs_bo == NULL) {
free(csg->base.packets); free(csg->base.packets);
@ -104,21 +106,22 @@ static struct radeon_cs *cs_gem_create(struct radeon_cs_manager *csm,
csg->chunks[1].chunk_id = RADEON_CHUNK_ID_RELOCS; csg->chunks[1].chunk_id = RADEON_CHUNK_ID_RELOCS;
csg->chunks[1].length_dw = 0; csg->chunks[1].length_dw = 0;
csg->chunks[1].chunk_data = (uint64_t)(uintptr_t)csg->relocs; csg->chunks[1].chunk_data = (uint64_t)(uintptr_t)csg->relocs;
return (struct radeon_cs*)csg; return (struct radeon_cs_int*)csg;
} }
static int cs_gem_write_reloc(struct radeon_cs *cs, static int cs_gem_write_reloc(struct radeon_cs_int *cs,
struct radeon_bo *bo, struct radeon_bo *bo,
uint32_t read_domain, uint32_t read_domain,
uint32_t write_domain, uint32_t write_domain,
uint32_t flags) uint32_t flags)
{ {
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
struct cs_gem *csg = (struct cs_gem*)cs; struct cs_gem *csg = (struct cs_gem*)cs;
struct cs_reloc_gem *reloc; struct cs_reloc_gem *reloc;
uint32_t idx; uint32_t idx;
unsigned i; unsigned i;
assert(bo->space_accounted); assert(boi->space_accounted);
/* check domains */ /* check domains */
if ((read_domain && write_domain) || (!read_domain && !write_domain)) { if ((read_domain && write_domain) || (!read_domain && !write_domain)) {
@ -162,8 +165,8 @@ static int cs_gem_write_reloc(struct radeon_cs *cs,
/* update flags */ /* update flags */
reloc->flags |= (flags & reloc->flags); reloc->flags |= (flags & reloc->flags);
/* write relocation packet */ /* write relocation packet */
radeon_cs_write_dword(cs, 0xc0001000); radeon_cs_write_dword((struct radeon_cs *)cs, 0xc0001000);
radeon_cs_write_dword(cs, idx); radeon_cs_write_dword((struct radeon_cs *)cs, idx);
return 0; return 0;
} }
} }
@ -176,7 +179,7 @@ static int cs_gem_write_reloc(struct radeon_cs *cs,
if (tmp == NULL) { if (tmp == NULL) {
return -ENOMEM; return -ENOMEM;
} }
csg->relocs_bo = (struct radeon_bo**)tmp; csg->relocs_bo = (struct radeon_bo_int **)tmp;
size = ((csg->nrelocs + 1) * RELOC_SIZE * 4); size = ((csg->nrelocs + 1) * RELOC_SIZE * 4);
tmp = (uint32_t*)realloc(csg->relocs, size); tmp = (uint32_t*)realloc(csg->relocs, size);
if (tmp == NULL) { if (tmp == NULL) {
@ -186,7 +189,7 @@ static int cs_gem_write_reloc(struct radeon_cs *cs,
csg->nrelocs += 1; csg->nrelocs += 1;
csg->chunks[1].chunk_data = (uint64_t)(uintptr_t)csg->relocs; csg->chunks[1].chunk_data = (uint64_t)(uintptr_t)csg->relocs;
} }
csg->relocs_bo[csg->base.crelocs] = bo; csg->relocs_bo[csg->base.crelocs] = boi;
idx = (csg->base.crelocs++) * RELOC_SIZE; idx = (csg->base.crelocs++) * RELOC_SIZE;
reloc = (struct cs_reloc_gem*)&csg->relocs[idx]; reloc = (struct cs_reloc_gem*)&csg->relocs[idx];
reloc->handle = bo->handle; reloc->handle = bo->handle;
@ -195,34 +198,32 @@ static int cs_gem_write_reloc(struct radeon_cs *cs,
reloc->flags = flags; reloc->flags = flags;
csg->chunks[1].length_dw += RELOC_SIZE; csg->chunks[1].length_dw += RELOC_SIZE;
radeon_bo_ref(bo); radeon_bo_ref(bo);
cs->relocs_total_size += bo->size; cs->relocs_total_size += boi->size;
radeon_cs_write_dword(cs, 0xc0001000); radeon_cs_write_dword((struct radeon_cs *)cs, 0xc0001000);
radeon_cs_write_dword(cs, idx); radeon_cs_write_dword((struct radeon_cs *)cs, idx);
return 0; return 0;
} }
static int cs_gem_begin(struct radeon_cs *cs, static int cs_gem_begin(struct radeon_cs_int *cs,
uint32_t ndw, uint32_t ndw,
const char *file, const char *file,
const char *func, const char *func,
int line) int line)
{ {
if (cs->section) { if (cs->section_ndw) {
fprintf(stderr, "CS already in a section(%s,%s,%d)\n", fprintf(stderr, "CS already in a section(%s,%s,%d)\n",
cs->section_file, cs->section_func, cs->section_line); cs->section_file, cs->section_func, cs->section_line);
fprintf(stderr, "CS can't start section(%s,%s,%d)\n", fprintf(stderr, "CS can't start section(%s,%s,%d)\n",
file, func, line); file, func, line);
return -EPIPE; return -EPIPE;
} }
cs->section = 1;
cs->section_ndw = ndw; cs->section_ndw = ndw;
cs->section_cdw = 0; cs->section_cdw = 0;
cs->section_file = file; cs->section_file = file;
cs->section_func = func; cs->section_func = func;
cs->section_line = line; cs->section_line = line;
if (cs->cdw + ndw > cs->ndw) { if (cs->cdw + ndw > cs->ndw) {
uint32_t tmp, *ptr; uint32_t tmp, *ptr;
@ -235,22 +236,20 @@ static int cs_gem_begin(struct radeon_cs *cs,
cs->packets = ptr; cs->packets = ptr;
cs->ndw = tmp; cs->ndw = tmp;
} }
return 0; return 0;
} }
static int cs_gem_end(struct radeon_cs *cs, static int cs_gem_end(struct radeon_cs_int *cs,
const char *file, const char *file,
const char *func, const char *func,
int line) int line)
{ {
if (!cs->section) { if (!cs->section_ndw) {
fprintf(stderr, "CS no section to end at (%s,%s,%d)\n", fprintf(stderr, "CS no section to end at (%s,%s,%d)\n",
file, func, line); file, func, line);
return -EPIPE; return -EPIPE;
} }
cs->section = 0;
if (cs->section_ndw != cs->section_cdw) { if (cs->section_ndw != cs->section_cdw) {
fprintf(stderr, "CS section size missmatch start at (%s,%s,%d) %d vs %d\n", fprintf(stderr, "CS section size missmatch start at (%s,%s,%d) %d vs %d\n",
cs->section_file, cs->section_func, cs->section_line, cs->section_ndw, cs->section_cdw); cs->section_file, cs->section_func, cs->section_line, cs->section_ndw, cs->section_cdw);
@ -258,10 +257,11 @@ static int cs_gem_end(struct radeon_cs *cs,
file, func, line); file, func, line);
return -EPIPE; return -EPIPE;
} }
cs->section_ndw = 0;
return 0; return 0;
} }
static int cs_gem_emit(struct radeon_cs *cs) static int cs_gem_emit(struct radeon_cs_int *cs)
{ {
struct cs_gem *csg = (struct cs_gem*)cs; struct cs_gem *csg = (struct cs_gem*)cs;
uint64_t chunk_array[2]; uint64_t chunk_array[2];
@ -280,7 +280,7 @@ static int cs_gem_emit(struct radeon_cs *cs)
&csg->cs, sizeof(struct drm_radeon_cs)); &csg->cs, sizeof(struct drm_radeon_cs));
for (i = 0; i < csg->base.crelocs; i++) { for (i = 0; i < csg->base.crelocs; i++) {
csg->relocs_bo[i]->space_accounted = 0; csg->relocs_bo[i]->space_accounted = 0;
radeon_bo_unref(csg->relocs_bo[i]); radeon_bo_unref((struct radeon_bo *)csg->relocs_bo[i]);
csg->relocs_bo[i] = NULL; csg->relocs_bo[i] = NULL;
} }
@ -290,7 +290,7 @@ static int cs_gem_emit(struct radeon_cs *cs)
return r; return r;
} }
static int cs_gem_destroy(struct radeon_cs *cs) static int cs_gem_destroy(struct radeon_cs_int *cs)
{ {
struct cs_gem *csg = (struct cs_gem*)cs; struct cs_gem *csg = (struct cs_gem*)cs;
@ -301,7 +301,7 @@ static int cs_gem_destroy(struct radeon_cs *cs)
return 0; return 0;
} }
static int cs_gem_erase(struct radeon_cs *cs) static int cs_gem_erase(struct radeon_cs_int *cs)
{ {
struct cs_gem *csg = (struct cs_gem*)cs; struct cs_gem *csg = (struct cs_gem*)cs;
unsigned i; unsigned i;
@ -309,21 +309,21 @@ static int cs_gem_erase(struct radeon_cs *cs)
if (csg->relocs_bo) { if (csg->relocs_bo) {
for (i = 0; i < csg->base.crelocs; i++) { for (i = 0; i < csg->base.crelocs; i++) {
if (csg->relocs_bo[i]) { if (csg->relocs_bo[i]) {
radeon_bo_unref(csg->relocs_bo[i]); radeon_bo_unref((struct radeon_bo *)csg->relocs_bo[i]);
csg->relocs_bo[i] = NULL; csg->relocs_bo[i] = NULL;
} }
} }
} }
cs->relocs_total_size = 0; cs->relocs_total_size = 0;
cs->cdw = 0; cs->cdw = 0;
cs->section = 0; cs->section_ndw = 0;
cs->crelocs = 0; cs->crelocs = 0;
csg->chunks[0].length_dw = 0; csg->chunks[0].length_dw = 0;
csg->chunks[1].length_dw = 0; csg->chunks[1].length_dw = 0;
return 0; return 0;
} }
static int cs_gem_need_flush(struct radeon_cs *cs) static int cs_gem_need_flush(struct radeon_cs_int *cs)
{ {
return 0; //(cs->relocs_total_size > (32*1024*1024)); return 0; //(cs->relocs_total_size > (32*1024*1024));
} }
@ -350,7 +350,7 @@ static int cs_gem_need_flush(struct radeon_cs *cs)
#define CP_PACKET0_GET_ONE_REG_WR(h) (((h) >> 15) & 1) #define CP_PACKET0_GET_ONE_REG_WR(h) (((h) >> 15) & 1)
#define CP_PACKET3_GET_OPCODE(h) (((h) >> 8) & 0xFF) #define CP_PACKET3_GET_OPCODE(h) (((h) >> 8) & 0xFF)
static void cs_gem_print(struct radeon_cs *cs, FILE *file) static void cs_gem_print(struct radeon_cs_int *cs, FILE *file)
{ {
unsigned opcode; unsigned opcode;
unsigned reg; unsigned reg;

66
radeon/radeon_cs_int.h Normal file
View File

@ -0,0 +1,66 @@
#ifndef _RADEON_CS_INT_H_
#define _RADEON_CS_INT_H_
struct radeon_cs_space_check {
struct radeon_bo_int *bo;
uint32_t read_domains;
uint32_t write_domain;
uint32_t new_accounted;
};
struct radeon_cs_int {
/* keep first two in same place */
uint32_t *packets;
unsigned cdw;
unsigned ndw;
unsigned section_ndw;
unsigned section_cdw;
/* private members */
struct radeon_cs_manager *csm;
void *relocs;
unsigned crelocs;
unsigned relocs_total_size;
const char *section_file;
const char *section_func;
int section_line;
struct radeon_cs_space_check bos[MAX_SPACE_BOS];
int bo_count;
void (*space_flush_fn)(void *);
void *space_flush_data;
};
/* cs functions */
struct radeon_cs_funcs {
struct radeon_cs_int *(*cs_create)(struct radeon_cs_manager *csm,
uint32_t ndw);
int (*cs_write_reloc)(struct radeon_cs_int *cs,
struct radeon_bo *bo,
uint32_t read_domain,
uint32_t write_domain,
uint32_t flags);
int (*cs_begin)(struct radeon_cs_int *cs,
uint32_t ndw,
const char *file,
const char *func,
int line);
int (*cs_end)(struct radeon_cs_int *cs,
const char *file, const char *func,
int line);
int (*cs_emit)(struct radeon_cs_int *cs);
int (*cs_destroy)(struct radeon_cs_int *cs);
int (*cs_erase)(struct radeon_cs_int *cs);
int (*cs_need_flush)(struct radeon_cs_int *cs);
void (*cs_print)(struct radeon_cs_int *cs, FILE *file);
};
struct radeon_cs_manager {
struct radeon_cs_funcs *funcs;
int fd;
int32_t vram_limit, gart_limit;
int32_t vram_write_used, gart_write_used;
int32_t read_used;
};
#endif

62
radeon/radeon_cs_space.c
View File

@ -29,6 +29,8 @@
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
#include "radeon_cs.h" #include "radeon_cs.h"
#include "radeon_bo_int.h"
#include "radeon_cs_int.h"
struct rad_sizes { struct rad_sizes {
int32_t op_read; int32_t op_read;
@ -39,7 +41,7 @@ struct rad_sizes {
static inline int radeon_cs_setup_bo(struct radeon_cs_space_check *sc, struct rad_sizes *sizes) static inline int radeon_cs_setup_bo(struct radeon_cs_space_check *sc, struct rad_sizes *sizes)
{ {
uint32_t read_domains, write_domain; uint32_t read_domains, write_domain;
struct radeon_bo *bo; struct radeon_bo_int *bo;
bo = sc->bo; bo = sc->bo;
sc->new_accounted = 0; sc->new_accounted = 0;
@ -47,7 +49,7 @@ static inline int radeon_cs_setup_bo(struct radeon_cs_space_check *sc, struct ra
write_domain = sc->write_domain; write_domain = sc->write_domain;
/* legacy needs a static check */ /* legacy needs a static check */
if (radeon_bo_is_static(bo)) { if (radeon_bo_is_static((struct radeon_bo *)sc->bo)) {
bo->space_accounted = sc->new_accounted = (read_domains << 16) | write_domain; bo->space_accounted = sc->new_accounted = (read_domains << 16) | write_domain;
return 0; return 0;
} }
@ -100,11 +102,11 @@ static inline int radeon_cs_setup_bo(struct radeon_cs_space_check *sc, struct ra
return 0; return 0;
} }
static int radeon_cs_do_space_check(struct radeon_cs *cs, struct radeon_cs_space_check *new_tmp) static int radeon_cs_do_space_check(struct radeon_cs_int *cs, struct radeon_cs_space_check *new_tmp)
{ {
struct radeon_cs_manager *csm = cs->csm; struct radeon_cs_manager *csm = cs->csm;
int i; int i;
struct radeon_bo *bo; struct radeon_bo_int *bo;
struct rad_sizes sizes; struct rad_sizes sizes;
int ret; int ret;
@ -158,25 +160,28 @@ static int radeon_cs_do_space_check(struct radeon_cs *cs, struct radeon_cs_space
void radeon_cs_space_add_persistent_bo(struct radeon_cs *cs, struct radeon_bo *bo, uint32_t read_domains, uint32_t write_domain) void radeon_cs_space_add_persistent_bo(struct radeon_cs *cs, struct radeon_bo *bo, uint32_t read_domains, uint32_t write_domain)
{ {
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
int i; int i;
for (i = 0; i < cs->bo_count; i++) { for (i = 0; i < csi->bo_count; i++) {
if (cs->bos[i].bo == bo && if (csi->bos[i].bo == boi &&
cs->bos[i].read_domains == read_domains && csi->bos[i].read_domains == read_domains &&
cs->bos[i].write_domain == write_domain) csi->bos[i].write_domain == write_domain)
return; return;
} }
radeon_bo_ref(bo); radeon_bo_ref(bo);
i = cs->bo_count; i = csi->bo_count;
cs->bos[i].bo = bo; csi->bos[i].bo = boi;
cs->bos[i].read_domains = read_domains; csi->bos[i].read_domains = read_domains;
cs->bos[i].write_domain = write_domain; csi->bos[i].write_domain = write_domain;
cs->bos[i].new_accounted = 0; csi->bos[i].new_accounted = 0;
cs->bo_count++; csi->bo_count++;
assert(cs->bo_count < MAX_SPACE_BOS); assert(csi->bo_count < MAX_SPACE_BOS);
} }
static int radeon_cs_check_space_internal(struct radeon_cs *cs, struct radeon_cs_space_check *tmp_bo) static int radeon_cs_check_space_internal(struct radeon_cs_int *cs,
struct radeon_cs_space_check *tmp_bo)
{ {
int ret; int ret;
int flushed = 0; int flushed = 0;
@ -199,36 +204,41 @@ int radeon_cs_space_check_with_bo(struct radeon_cs *cs,
struct radeon_bo *bo, struct radeon_bo *bo,
uint32_t read_domains, uint32_t write_domain) uint32_t read_domains, uint32_t write_domain)
{ {
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
struct radeon_bo_int *boi = (struct radeon_bo_int *)bo;
struct radeon_cs_space_check temp_bo; struct radeon_cs_space_check temp_bo;
int ret = 0; int ret = 0;
if (bo) { if (bo) {
temp_bo.bo = bo; temp_bo.bo = boi;
temp_bo.read_domains = read_domains; temp_bo.read_domains = read_domains;
temp_bo.write_domain = write_domain; temp_bo.write_domain = write_domain;
temp_bo.new_accounted = 0; temp_bo.new_accounted = 0;
} }
ret = radeon_cs_check_space_internal(cs, bo ? &temp_bo : NULL); ret = radeon_cs_check_space_internal(csi, bo ? &temp_bo : NULL);
return ret; return ret;
} }
int radeon_cs_space_check(struct radeon_cs *cs) int radeon_cs_space_check(struct radeon_cs *cs)
{ {
return radeon_cs_check_space_internal(cs, NULL); struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
return radeon_cs_check_space_internal(csi, NULL);
} }
void radeon_cs_space_reset_bos(struct radeon_cs *cs) void radeon_cs_space_reset_bos(struct radeon_cs *cs)
{ {
struct radeon_cs_int *csi = (struct radeon_cs_int *)cs;
int i; int i;
for (i = 0; i < cs->bo_count; i++) { for (i = 0; i < csi->bo_count; i++) {
radeon_bo_unref(cs->bos[i].bo); radeon_bo_unref((struct radeon_bo *)csi->bos[i].bo);
cs->bos[i].bo = NULL; csi->bos[i].bo = NULL;
cs->bos[i].read_domains = 0; csi->bos[i].read_domains = 0;
cs->bos[i].write_domain = 0; csi->bos[i].write_domain = 0;
cs->bos[i].new_accounted = 0; csi->bos[i].new_accounted = 0;
} }
cs->bo_count = 0; csi->bo_count = 0;
} }

141
radeon/radeon_track.c
View File

@ -1,141 +0,0 @@
/*
* Copyright © 2008 Jérôme Glisse
* All Rights Reserved.
*
* 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 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 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 COPYRIGHT HOLDERS, AUTHORS
* AND/OR ITS 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.
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*/
/*
* Authors:
* Jérôme Glisse <glisse@freedesktop.org>
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "radeon_track.h"
void radeon_track_add_event(struct radeon_track *track,
const char *file,
const char *func,
const char *op,
unsigned line)
{
struct radeon_track_event *event;
if (track == NULL) {
return;
}
event = (void*)calloc(1,sizeof(struct radeon_track_event));
if (event == NULL) {
return;
}
event->line = line;
event->file = strdup(file);
event->func = strdup(func);
event->op = strdup(op);
if (event->file == NULL || event->func == NULL || event->op == NULL) {
free(event->file);
free(event->func);
free(event->op);
free(event);
return;
}
event->next = track->events;
track->events = event;
}
struct radeon_track *radeon_tracker_add_track(struct radeon_tracker *tracker,
unsigned key)
{
struct radeon_track *track;
track = (struct radeon_track*)calloc(1, sizeof(struct radeon_track));
if (track) {
track->next = tracker->tracks.next;
track->prev = &tracker->tracks;
tracker->tracks.next = track;
if (track->next) {
track->next->prev = track;
}
track->key = key;
track->events = NULL;
}
return track;
}
void radeon_tracker_remove_track(struct radeon_tracker *tracker,
struct radeon_track *track)
{
struct radeon_track_event *event;
void *tmp;
if (track == NULL) {
return;
}
track->prev->next = track->next;
if (track->next) {
track->next->prev = track->prev;
}
track->next = track->prev = NULL;
event = track->events;
while (event) {
tmp = event;
free(event->file);
free(event->func);
free(event->op);
event = event->next;
free(tmp);
}
track->events = NULL;
free(track);
}
void radeon_tracker_print(struct radeon_tracker *tracker, FILE *file)
{
struct radeon_track *track;
struct radeon_track_event *event;
void *tmp;
track = tracker->tracks.next;
while (track) {
event = track->events;
fprintf(file, "[0x%08X] :\n", track->key);
while (event) {
tmp = event;
fprintf(file, " [0x%08X:%s](%s:%s:%d)\n",
track->key, event->op, event->file,
event->func, event->line);
free(event->file);
free(event->func);
free(event->op);
event->file = NULL;
event->func = NULL;
event->op = NULL;
event = event->next;
free(tmp);
}
track->events = NULL;
tmp = track;
track = track->next;
free(tmp);
}
tracker->tracks.next = NULL;
}

64
radeon/radeon_track.h
View File

@ -1,64 +0,0 @@
/*
* Copyright © 2008 Jérôme Glisse
* All Rights Reserved.
*
* 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 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 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 COPYRIGHT HOLDERS, AUTHORS
* AND/OR ITS 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.
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*/
/*
* Authors:
* Jérôme Glisse <glisse@freedesktop.org>
*/
#ifndef RADEON_TRACK_H
#define RADEON_TRACK_H
struct radeon_track_event {
struct radeon_track_event *next;
char *file;
char *func;
char *op;
unsigned line;
};
struct radeon_track {
struct radeon_track *next;
struct radeon_track *prev;
unsigned key;
struct radeon_track_event *events;
};
struct radeon_tracker {
struct radeon_track tracks;
};
void radeon_track_add_event(struct radeon_track *track,
const char *file,
const char *func,
const char *op,
unsigned line);
struct radeon_track *radeon_tracker_add_track(struct radeon_tracker *tracker,
unsigned key);
void radeon_tracker_remove_track(struct radeon_tracker *tracker,
struct radeon_track *track);
void radeon_tracker_print(struct radeon_tracker *tracker,
FILE *file);
#endif