* Rob Clark <robclark@freedesktop.org>
*/
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
#include "freedreno_drmif.h"
#include "freedreno_priv.h"
-static pthread_mutex_t table_lock = PTHREAD_MUTEX_INITIALIZER;
-
-static void bo_del(struct fd_bo *bo);
+drm_private pthread_mutex_t table_lock = PTHREAD_MUTEX_INITIALIZER;
+drm_private void bo_del(struct fd_bo *bo);
/* set buffer name, and add to table, call w/ table_lock held: */
static void set_name(struct fd_bo *bo, uint32_t name)
return bo;
}
-/* Frees older cached buffers. Called under table_lock */
-drm_private void fd_cleanup_bo_cache(struct fd_device *dev, time_t time)
-{
- int i;
-
- if (dev->time == time)
- return;
-
- for (i = 0; i < dev->num_buckets; i++) {
- struct fd_bo_bucket *bucket = &dev->cache_bucket[i];
- struct fd_bo *bo;
-
- while (!LIST_IS_EMPTY(&bucket->list)) {
- bo = LIST_ENTRY(struct fd_bo, bucket->list.next, list);
-
- /* keep things in cache for at least 1 second: */
- if (time && ((time - bo->free_time) <= 1))
- break;
-
- list_del(&bo->list);
- bo_del(bo);
- }
- }
-
- dev->time = time;
-}
-
-static struct fd_bo_bucket * get_bucket(struct fd_device *dev, uint32_t size)
-{
- int i;
-
- /* hmm, this is what intel does, but I suppose we could calculate our
- * way to the correct bucket size rather than looping..
- */
- for (i = 0; i < dev->num_buckets; i++) {
- struct fd_bo_bucket *bucket = &dev->cache_bucket[i];
- if (bucket->size >= size) {
- return bucket;
- }
- }
-
- return NULL;
-}
-
-static int is_idle(struct fd_bo *bo)
-{
- return fd_bo_cpu_prep(bo, NULL,
- DRM_FREEDRENO_PREP_READ |
- DRM_FREEDRENO_PREP_WRITE |
- DRM_FREEDRENO_PREP_NOSYNC) == 0;
-}
-
-static struct fd_bo *find_in_bucket(struct fd_device *dev,
- struct fd_bo_bucket *bucket, uint32_t flags)
-{
- struct fd_bo *bo = NULL;
-
- /* TODO .. if we had an ALLOC_FOR_RENDER flag like intel, we could
- * skip the busy check.. if it is only going to be a render target
- * then we probably don't need to stall..
- *
- * NOTE that intel takes ALLOC_FOR_RENDER bo's from the list tail
- * (MRU, since likely to be in GPU cache), rather than head (LRU)..
- */
- pthread_mutex_lock(&table_lock);
- while (!LIST_IS_EMPTY(&bucket->list)) {
- bo = LIST_ENTRY(struct fd_bo, bucket->list.next, list);
- if (0 /* TODO: if madvise tells us bo is gone... */) {
- list_del(&bo->list);
- bo_del(bo);
- bo = NULL;
- continue;
- }
- /* TODO check for compatible flags? */
- if (is_idle(bo)) {
- list_del(&bo->list);
- break;
- }
- bo = NULL;
- break;
- }
- pthread_mutex_unlock(&table_lock);
-
- return bo;
-}
-
-
-struct fd_bo *
-fd_bo_new(struct fd_device *dev, uint32_t size, uint32_t flags)
+static struct fd_bo *
+bo_new(struct fd_device *dev, uint32_t size, uint32_t flags,
+ struct fd_bo_cache *cache)
{
struct fd_bo *bo = NULL;
- struct fd_bo_bucket *bucket;
uint32_t handle;
int ret;
- size = ALIGN(size, 4096);
- bucket = get_bucket(dev, size);
-
- /* see if we can be green and recycle: */
- if (bucket) {
- size = bucket->size;
- bo = find_in_bucket(dev, bucket, flags);
- if (bo) {
- atomic_set(&bo->refcnt, 1);
- fd_device_ref(bo->dev);
- return bo;
- }
- }
+ bo = fd_bo_cache_alloc(cache, &size, flags);
+ if (bo)
+ return bo;
ret = dev->funcs->bo_new_handle(dev, size, flags, &handle);
if (ret)
pthread_mutex_lock(&table_lock);
bo = bo_from_handle(dev, size, handle);
- bo->bo_reuse = 1;
pthread_mutex_unlock(&table_lock);
+ VG_BO_ALLOC(bo);
+
+ return bo;
+}
+
+drm_public struct fd_bo *
+fd_bo_new(struct fd_device *dev, uint32_t size, uint32_t flags)
+{
+ struct fd_bo *bo = bo_new(dev, size, flags, &dev->bo_cache);
+ if (bo)
+ bo->bo_reuse = BO_CACHE;
+ return bo;
+}
+
+/* internal function to allocate bo's that use the ringbuffer cache
+ * instead of the normal bo_cache. The purpose is, because cmdstream
+ * bo's get vmap'd on the kernel side, and that is expensive, we want
+ * to re-use cmdstream bo's for cmdstream and not unrelated purposes.
+ */
+drm_private struct fd_bo *
+fd_bo_new_ring(struct fd_device *dev, uint32_t size, uint32_t flags)
+{
+ struct fd_bo *bo = bo_new(dev, size, flags, &dev->ring_cache);
+ if (bo)
+ bo->bo_reuse = RING_CACHE;
return bo;
}
-struct fd_bo *
+drm_public struct fd_bo *
fd_bo_from_handle(struct fd_device *dev, uint32_t handle, uint32_t size)
{
struct fd_bo *bo = NULL;
bo = bo_from_handle(dev, size, handle);
+ VG_BO_ALLOC(bo);
+
out_unlock:
pthread_mutex_unlock(&table_lock);
return bo;
}
-struct fd_bo *
+drm_public struct fd_bo *
fd_bo_from_dmabuf(struct fd_device *dev, int fd)
{
int ret, size;
pthread_mutex_lock(&table_lock);
ret = drmPrimeFDToHandle(dev->fd, fd, &handle);
if (ret) {
+ pthread_mutex_unlock(&table_lock);
return NULL;
}
bo = bo_from_handle(dev, size, handle);
+ VG_BO_ALLOC(bo);
+
out_unlock:
pthread_mutex_unlock(&table_lock);
return bo;
}
-struct fd_bo * fd_bo_from_name(struct fd_device *dev, uint32_t name)
+drm_public struct fd_bo * fd_bo_from_name(struct fd_device *dev, uint32_t name)
{
struct drm_gem_open req = {
.name = name,
goto out_unlock;
bo = bo_from_handle(dev, req.size, req.handle);
- if (bo)
+ if (bo) {
set_name(bo, name);
+ VG_BO_ALLOC(bo);
+ }
out_unlock:
pthread_mutex_unlock(&table_lock);
return bo;
}
-struct fd_bo * fd_bo_ref(struct fd_bo *bo)
+drm_public uint64_t fd_bo_get_iova(struct fd_bo *bo)
+{
+ return bo->funcs->iova(bo);
+}
+
+drm_public void fd_bo_put_iova(struct fd_bo *bo)
+{
+ /* currently a no-op */
+}
+
+drm_public struct fd_bo * fd_bo_ref(struct fd_bo *bo)
{
atomic_inc(&bo->refcnt);
return bo;
}
-void fd_bo_del(struct fd_bo *bo)
+drm_public void fd_bo_del(struct fd_bo *bo)
{
struct fd_device *dev = bo->dev;
pthread_mutex_lock(&table_lock);
- if (bo->bo_reuse) {
- struct fd_bo_bucket *bucket = get_bucket(dev, bo->size);
-
- /* see if we can be green and recycle: */
- if (bucket) {
- struct timespec time;
-
- clock_gettime(CLOCK_MONOTONIC, &time);
-
- bo->free_time = time.tv_sec;
- list_addtail(&bo->list, &bucket->list);
- fd_cleanup_bo_cache(dev, time.tv_sec);
-
- /* bo's in the bucket cache don't have a ref and
- * don't hold a ref to the dev:
- */
-
- goto out;
- }
- }
+ if ((bo->bo_reuse == BO_CACHE) && (fd_bo_cache_free(&dev->bo_cache, bo) == 0))
+ goto out;
+ if ((bo->bo_reuse == RING_CACHE) && (fd_bo_cache_free(&dev->ring_cache, bo) == 0))
+ goto out;
bo_del(bo);
-out:
fd_device_del_locked(dev);
+out:
pthread_mutex_unlock(&table_lock);
}
/* Called under table_lock */
-static void bo_del(struct fd_bo *bo)
+drm_private void bo_del(struct fd_bo *bo)
{
+ VG_BO_FREE(bo);
+
if (bo->map)
drm_munmap(bo->map, bo->size);
bo->funcs->destroy(bo);
}
-int fd_bo_get_name(struct fd_bo *bo, uint32_t *name)
+drm_public int fd_bo_get_name(struct fd_bo *bo, uint32_t *name)
{
if (!bo->name) {
struct drm_gem_flink req = {
pthread_mutex_lock(&table_lock);
set_name(bo, req.name);
pthread_mutex_unlock(&table_lock);
- bo->bo_reuse = 0;
+ bo->bo_reuse = NO_CACHE;
}
*name = bo->name;
return 0;
}
-uint32_t fd_bo_handle(struct fd_bo *bo)
+drm_public uint32_t fd_bo_handle(struct fd_bo *bo)
{
return bo->handle;
}
-int fd_bo_dmabuf(struct fd_bo *bo)
+drm_public int fd_bo_dmabuf(struct fd_bo *bo)
{
int ret, prime_fd;
return ret;
}
- bo->bo_reuse = 0;
+ bo->bo_reuse = NO_CACHE;
return prime_fd;
}
-uint32_t fd_bo_size(struct fd_bo *bo)
+drm_public uint32_t fd_bo_size(struct fd_bo *bo)
{
return bo->size;
}
-void * fd_bo_map(struct fd_bo *bo)
+drm_public void * fd_bo_map(struct fd_bo *bo)
{
if (!bo->map) {
uint64_t offset;
}
/* a bit odd to take the pipe as an arg, but it's a, umm, quirk of kgsl.. */
-int fd_bo_cpu_prep(struct fd_bo *bo, struct fd_pipe *pipe, uint32_t op)
+drm_public int fd_bo_cpu_prep(struct fd_bo *bo, struct fd_pipe *pipe, uint32_t op)
{
return bo->funcs->cpu_prep(bo, pipe, op);
}
-void fd_bo_cpu_fini(struct fd_bo *bo)
+drm_public void fd_bo_cpu_fini(struct fd_bo *bo)
{
bo->funcs->cpu_fini(bo);
}
-#ifndef HAVE_FREEDRENO_KGSL
-struct fd_bo * fd_bo_from_fbdev(struct fd_pipe *pipe, int fbfd, uint32_t size)
+#if !HAVE_FREEDRENO_KGSL
+drm_public struct fd_bo * fd_bo_from_fbdev(struct fd_pipe *pipe, int fbfd, uint32_t size)
{
return NULL;
}