Correctly handle different page sizes in the memory accounting.
Signed-off-by: Christian König <christian.koenig@amd.com>
Reviewed-by: Felix Kuehling <Felix.Kuehling@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
 EXPORT_SYMBOL(ttm_mem_global_alloc);
 
 int ttm_mem_global_alloc_page(struct ttm_mem_global *glob,
-                             struct page *page)
+                             struct page *page, uint64_t size)
 {
 
        struct ttm_mem_zone *zone = NULL;
        if (glob->zone_dma32 && page_to_pfn(page) > 0x00100000UL)
                zone = glob->zone_kernel;
 #endif
-       return ttm_mem_global_alloc_zone(glob, zone, PAGE_SIZE, false, false);
+       return ttm_mem_global_alloc_zone(glob, zone, size, false, false);
 }
 
-void ttm_mem_global_free_page(struct ttm_mem_global *glob, struct page *page)
+void ttm_mem_global_free_page(struct ttm_mem_global *glob, struct page *page,
+                             uint64_t size)
 {
        struct ttm_mem_zone *zone = NULL;
 
        if (glob->zone_dma32 && page_to_pfn(page) > 0x00100000UL)
                zone = glob->zone_kernel;
 #endif
-       ttm_mem_global_free_zone(glob, zone, PAGE_SIZE);
+       ttm_mem_global_free_zone(glob, zone, size);
 }
 
-
 size_t ttm_round_pot(size_t size)
 {
        if ((size & (size - 1)) == 0)
 
                        return -ENOMEM;
                }
 
-               ret = ttm_mem_global_alloc_page(mem_glob, ttm->pages[i]);
+               ret = ttm_mem_global_alloc_page(mem_glob, ttm->pages[i],
+                                               PAGE_SIZE);
                if (unlikely(ret != 0)) {
                        ttm_pool_unpopulate(ttm);
                        return -ENOMEM;
        for (i = 0; i < ttm->num_pages; ++i) {
                if (ttm->pages[i]) {
                        ttm_mem_global_free_page(ttm->glob->mem_glob,
-                                                ttm->pages[i]);
+                                                ttm->pages[i], PAGE_SIZE);
                        ttm_put_pages(&ttm->pages[i], 1,
                                      ttm->page_flags,
                                      ttm->caching_state);
 
                        return -ENOMEM;
                }
 
-               ret = ttm_mem_global_alloc_page(mem_glob, ttm->pages[i]);
+               ret = ttm_mem_global_alloc_page(mem_glob, ttm->pages[i],
+                                               pool->size);
                if (unlikely(ret != 0)) {
                        ttm_dma_unpopulate(ttm_dma, dev);
                        return -ENOMEM;
        if (is_cached) {
                list_for_each_entry_safe(d_page, next, &ttm_dma->pages_list, page_list) {
                        ttm_mem_global_free_page(ttm->glob->mem_glob,
-                                                d_page->p);
+                                                d_page->p, pool->size);
                        ttm_dma_page_put(pool, d_page);
                }
        } else {
                for (i = 0; i < count; i++) {
                        ttm_mem_global_free_page(ttm->glob->mem_glob,
-                                                ttm->pages[i]);
+                                                ttm->pages[i], pool->size);
                }
        }
 
 
 extern void ttm_mem_global_free(struct ttm_mem_global *glob,
                                uint64_t amount);
 extern int ttm_mem_global_alloc_page(struct ttm_mem_global *glob,
-                                    struct page *page);
+                                    struct page *page, uint64_t size);
 extern void ttm_mem_global_free_page(struct ttm_mem_global *glob,
-                                    struct page *page);
+                                    struct page *page, uint64_t size);
 extern size_t ttm_round_pot(size_t size);
 extern uint64_t ttm_get_kernel_zone_memory_size(struct ttm_mem_global *glob);
 #endif