Simplify the ttm backend interface and the agp ttm backend.

diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index d879c2a..271c6c8 100644 (file)
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -834,14 +834,12 @@ typedef struct drm_device {
 } drm_device_t;
 
 #if __OS_HAS_AGP
-typedef struct drm_agp_ttm_priv {
+typedef struct drm_agp_ttm_backend {
+        drm_ttm_backend_t backend;
        DRM_AGP_MEM *mem;
        struct agp_bridge_data *bridge;
-       unsigned alloc_type;
-       unsigned cached_type;
-       unsigned uncached_type;
        int populated;
-} drm_agp_ttm_priv;
+} drm_agp_ttm_backend_t;
 #endif
 
 
@@ -1118,8 +1116,7 @@ extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size
 extern int drm_agp_free_memory(DRM_AGP_MEM * handle);
 extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start);
 extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
-extern drm_ttm_backend_t *drm_agp_init_ttm(struct drm_device *dev,
-                                          drm_ttm_backend_t *backend);
+extern drm_ttm_backend_t *drm_agp_init_ttm(struct drm_device *dev);
                                /* Stub support (drm_stub.h) */
 extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
                     struct drm_driver *driver);

diff --git a/linux-core/drm_agpsupport.c b/linux-core/drm_agpsupport.c
index 0f7b1d2..7d8f073 100644 (file)
--- a/linux-core/drm_agpsupport.c
+++ b/linux-core/drm_agpsupport.c
@@ -570,7 +570,8 @@ static int drm_agp_needs_unbind_cache_adjust(drm_ttm_backend_t *backend) {
 static int drm_agp_populate(drm_ttm_backend_t *backend, unsigned long num_pages,
                            struct page **pages) {
 
-       drm_agp_ttm_priv *agp_priv = (drm_agp_ttm_priv *) backend->private;
+       drm_agp_ttm_backend_t *agp_be = 
+               container_of(backend, drm_agp_ttm_backend_t, backend);
        struct page **cur_page, **last_page = pages + num_pages;
        DRM_AGP_MEM *mem;
 
@@ -579,9 +580,9 @@ static int drm_agp_populate(drm_ttm_backend_t *backend, unsigned long num_pages,
 
        DRM_DEBUG("drm_agp_populate_ttm\n");
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
-       mem = drm_agp_allocate_memory(num_pages, agp_priv->alloc_type);
+       mem = drm_agp_allocate_memory(num_pages, AGP_USER_MEMORY);
 #else
-       mem = drm_agp_allocate_memory(agp_priv->bridge, num_pages, agp_priv->alloc_type);
+       mem = drm_agp_allocate_memory(agp_be->bridge, num_pages, AGP_USER_MEMORY);
 #endif
        if (!mem) {
                drm_free_memctl(num_pages *sizeof(void *));
@@ -593,7 +594,7 @@ static int drm_agp_populate(drm_ttm_backend_t *backend, unsigned long num_pages,
        for (cur_page = pages; cur_page < last_page; ++cur_page) {
                mem->memory[mem->page_count++] = phys_to_gart(page_to_phys(*cur_page));
        }
-       agp_priv->mem = mem;
+       agp_be->mem = mem;
        return 0;
 }
 
@@ -601,76 +602,82 @@ static int drm_agp_bind_ttm(drm_ttm_backend_t *backend,
                            unsigned long offset,
                            int cached)
 {
-       drm_agp_ttm_priv *agp_priv = (drm_agp_ttm_priv *) backend->private;
-       DRM_AGP_MEM *mem = agp_priv->mem;
+       drm_agp_ttm_backend_t *agp_be = 
+               container_of(backend, drm_agp_ttm_backend_t, backend);
+       DRM_AGP_MEM *mem = agp_be->mem;
        int ret;
 
        DRM_DEBUG("drm_agp_bind_ttm\n");
-       DRM_FLAG_MASKED(backend->flags, (cached) ? DRM_BE_FLAG_BOUND_CACHED : 0,
-                       DRM_BE_FLAG_BOUND_CACHED);
        mem->is_flushed = TRUE;
-       mem->type = (cached) ? agp_priv->cached_type : agp_priv->uncached_type;
+       mem->type = (cached) ? AGP_USER_CACHED_MEMORY : 
+               AGP_USER_MEMORY;
        ret = drm_agp_bind_memory(mem, offset);
        if (ret) {
                DRM_ERROR("AGP Bind memory failed\n");
        }
+       DRM_FLAG_MASKED(backend->flags, (cached) ? DRM_BE_FLAG_BOUND_CACHED : 0,
+                       DRM_BE_FLAG_BOUND_CACHED);
        return ret;
 }
 
 static int drm_agp_unbind_ttm(drm_ttm_backend_t *backend) {
 
-       drm_agp_ttm_priv *agp_priv = (drm_agp_ttm_priv *) backend->private;
+       drm_agp_ttm_backend_t *agp_be = 
+               container_of(backend, drm_agp_ttm_backend_t, backend);
 
        DRM_DEBUG("drm_agp_unbind_ttm\n");
-       if (agp_priv->mem->is_bound)
-               return drm_agp_unbind_memory(agp_priv->mem);
+       if (agp_be->mem->is_bound)
+               return drm_agp_unbind_memory(agp_be->mem);
        else
                return 0;
 }
 
 static void drm_agp_clear_ttm(drm_ttm_backend_t *backend) {
 
-       drm_agp_ttm_priv *agp_priv = (drm_agp_ttm_priv *) backend->private;
-       DRM_AGP_MEM *mem = agp_priv->mem;
+       drm_agp_ttm_backend_t *agp_be = 
+               container_of(backend, drm_agp_ttm_backend_t, backend);
+       DRM_AGP_MEM *mem = agp_be->mem;
 
        DRM_DEBUG("drm_agp_clear_ttm\n");
        if (mem) {
                unsigned long num_pages = mem->page_count;
-               backend->unbind(backend);
+               backend->func->unbind(backend);
                agp_free_memory(mem);
                drm_free_memctl(num_pages *sizeof(void *));
        }
-
-       agp_priv->mem = NULL;
+       agp_be->mem = NULL;
 }
 
 static void drm_agp_destroy_ttm(drm_ttm_backend_t *backend) {
 
-       drm_agp_ttm_priv *agp_priv;
+       drm_agp_ttm_backend_t *agp_be;
 
        if (backend) {
                DRM_DEBUG("drm_agp_destroy_ttm\n");
-               agp_priv = (drm_agp_ttm_priv *) backend->private;
-               if (agp_priv) {
-                       if (agp_priv->mem) {
-                               backend->clear(backend);
+               agp_be = container_of(backend, drm_agp_ttm_backend_t, backend);
+               if (agp_be) {
+                       if (agp_be->mem) {
+                               backend->func->clear(backend);
                        }
-                       drm_ctl_free(agp_priv, sizeof(*agp_priv), DRM_MEM_MAPPINGS);
-                       backend->private = NULL;
-               }
-               if (backend->flags & DRM_BE_FLAG_NEEDS_FREE) {
-                       drm_ctl_free(backend, sizeof(*backend), DRM_MEM_MAPPINGS);
+                       drm_ctl_free(agp_be, sizeof(*agp_be), DRM_MEM_TTM);
                }
        }
 }
 
-
-drm_ttm_backend_t *drm_agp_init_ttm(struct drm_device *dev,
-                                   drm_ttm_backend_t *backend)
+static drm_ttm_backend_func_t agp_ttm_backend = 
+{
+       .needs_ub_cache_adjust = drm_agp_needs_unbind_cache_adjust,
+       .populate = drm_agp_populate,
+       .clear = drm_agp_clear_ttm,
+       .bind = drm_agp_bind_ttm,
+       .unbind = drm_agp_unbind_ttm,
+       .destroy =  drm_agp_destroy_ttm,
+};
+
+drm_ttm_backend_t *drm_agp_init_ttm(struct drm_device *dev)
 {
 
-        drm_ttm_backend_t *agp_be;
-       drm_agp_ttm_priv *agp_priv;
+       drm_agp_ttm_backend_t *agp_be;
        struct agp_kern_info *info;
 
        if (!dev->agp) {
@@ -690,37 +697,19 @@ drm_ttm_backend_t *drm_agp_init_ttm(struct drm_device *dev,
                return NULL;
        }
 
-       agp_be = (backend != NULL) ? backend:
-               drm_ctl_calloc(1, sizeof(*agp_be), DRM_MEM_MAPPINGS);
-
+       
+       agp_be = drm_ctl_calloc(1, sizeof(*agp_be), DRM_MEM_TTM);
        if (!agp_be)
                return NULL;
 
-       agp_priv = drm_ctl_calloc(1, sizeof(*agp_priv), DRM_MEM_MAPPINGS);
-
-       if (!agp_priv) {
-               drm_ctl_free(agp_be, sizeof(*agp_be), DRM_MEM_MAPPINGS);
-               return NULL;
-       }
+       agp_be->mem = NULL;
 
+       agp_be->bridge = dev->agp->bridge;
+       agp_be->populated = FALSE;
+       agp_be->backend.func = &agp_ttm_backend;
+       agp_be->backend.mem_type = DRM_BO_MEM_TT;
 
-       agp_priv->mem = NULL;
-       agp_priv->alloc_type = AGP_USER_MEMORY;
-       agp_priv->cached_type = AGP_USER_CACHED_MEMORY;
-       agp_priv->uncached_type = AGP_USER_MEMORY;
-       agp_priv->bridge = dev->agp->bridge;
-       agp_priv->populated = FALSE;
-       agp_be->private = (void *) agp_priv;
-       agp_be->needs_ub_cache_adjust = drm_agp_needs_unbind_cache_adjust;
-       agp_be->populate = drm_agp_populate;
-       agp_be->clear = drm_agp_clear_ttm;
-       agp_be->bind = drm_agp_bind_ttm;
-       agp_be->unbind = drm_agp_unbind_ttm;
-       agp_be->destroy = drm_agp_destroy_ttm;
-       DRM_FLAG_MASKED(agp_be->flags, (backend == NULL) ? DRM_BE_FLAG_NEEDS_FREE : 0,
-                       DRM_BE_FLAG_NEEDS_FREE);
-       agp_be->drm_map_type = _DRM_AGP;
-       return agp_be;
+       return &agp_be->backend;
 }
 EXPORT_SYMBOL(drm_agp_init_ttm);
 

diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h
index b3155af..fa26e91 100644 (file)
--- a/linux-core/drm_objects.h
+++ b/linux-core/drm_objects.h
@@ -234,10 +234,8 @@ extern int drm_fence_ioctl(DRM_IOCTL_ARGS);
 #define DRM_BE_FLAG_NEEDS_FREE     0x00000001
 #define DRM_BE_FLAG_BOUND_CACHED   0x00000002
 
-typedef struct drm_ttm_backend {
-       void *private;
-       uint32_t flags;
-       uint32_t drm_map_type;
+struct drm_ttm_backend;
+typedef struct drm_ttm_backend_func {
        int (*needs_ub_cache_adjust) (struct drm_ttm_backend * backend);
        int (*populate) (struct drm_ttm_backend * backend,
                         unsigned long num_pages, struct page ** pages);
@@ -246,6 +244,13 @@ typedef struct drm_ttm_backend {
                     unsigned long offset, int cached);
        int (*unbind) (struct drm_ttm_backend * backend);
        void (*destroy) (struct drm_ttm_backend * backend);
+} drm_ttm_backend_func_t;
+
+
+typedef struct drm_ttm_backend {
+        uint32_t flags;
+        int mem_type;
+        drm_ttm_backend_func_t *func;
 } drm_ttm_backend_t;
 
 typedef struct drm_ttm {

diff --git a/linux-core/drm_ttm.c b/linux-core/drm_ttm.c
index 2556634..31503c9 100644 (file)
--- a/linux-core/drm_ttm.c
+++ b/linux-core/drm_ttm.c
@@ -154,7 +154,7 @@ int drm_destroy_ttm(drm_ttm_t * ttm)
 
        be = ttm->be;
        if (be) {
-               be->destroy(be);
+               be->func->destroy(be);
                ttm->be = NULL;
        }
 
@@ -222,7 +222,7 @@ static int drm_ttm_populate(drm_ttm_t * ttm)
                if (!page)
                        return -ENOMEM;
        }
-       be->populate(be, ttm->num_pages, ttm->pages);
+       be->func->populate(be, ttm->num_pages, ttm->pages);
        ttm->state = ttm_unbound;
        return 0;
 }
@@ -281,7 +281,7 @@ void drm_ttm_evict(drm_ttm_t * ttm)
        int ret;
 
        if (ttm->state == ttm_bound) {
-               ret = be->unbind(be);
+               ret = be->func->unbind(be);
                BUG_ON(ret);
        }
 
@@ -293,7 +293,7 @@ void drm_ttm_fixup_caching(drm_ttm_t * ttm)
 
        if (ttm->state == ttm_evicted) {
                drm_ttm_backend_t *be = ttm->be;
-               if (be->needs_ub_cache_adjust(be)) {
+               if (be->func->needs_ub_cache_adjust(be)) {
                        drm_set_caching(ttm, 0);
                }
                ttm->state = ttm_unbound;
@@ -329,7 +329,7 @@ int drm_bind_ttm(drm_ttm_t * ttm, int cached, unsigned long aper_offset)
                drm_set_caching(ttm, DRM_TTM_PAGE_UNCACHED);
        }
 
-       if ((ret = be->bind(be, aper_offset, cached))) {
+       if ((ret = be->func->bind(be, aper_offset, cached))) {
                ttm->state = ttm_evicted;
                DRM_ERROR("Couldn't bind backend.\n");
                return ret;

diff --git a/linux-core/i915_buffer.c b/linux-core/i915_buffer.c
index 8797de8..8589f46 100644 (file)
--- a/linux-core/i915_buffer.c
+++ b/linux-core/i915_buffer.c
@@ -35,7 +35,7 @@
 
 drm_ttm_backend_t *i915_create_ttm_backend_entry(drm_device_t * dev)
 {
-       return drm_agp_init_ttm(dev, NULL);
+       return drm_agp_init_ttm(dev);
 }
 
 int i915_fence_types(drm_buffer_object_t *bo, uint32_t * class, uint32_t * type)