diff options
author | Eric Anholt | 2008-04-28 18:54:53 -0500 |
---|---|---|
committer | Eric Anholt | 2008-04-28 18:54:53 -0500 |
commit | 3ad8db2071d30c198403e605f2726fc5c3e46bfd (patch) | |
tree | 93ff7f1c47f553ae1cc20816cce9457d5c5878ee /linux-core | |
parent | 22877864c204139fe1c46899bedd237e38f0e849 (diff) | |
download | external-libdrm-3ad8db2071d30c198403e605f2726fc5c3e46bfd.tar.gz external-libdrm-3ad8db2071d30c198403e605f2726fc5c3e46bfd.tar.xz external-libdrm-3ad8db2071d30c198403e605f2726fc5c3e46bfd.zip |
Rename drm_mm.c and its fuctions to drm_memrange.
It's not really a graphics memory allocator, just something to track ranges
of address space. It doesn't involve actual allocation, and was consuming
some desired namespace.
Diffstat (limited to 'linux-core')
-rw-r--r-- | linux-core/Makefile.kernel | 2 | ||||
-rw-r--r-- | linux-core/drmP.h | 43 | ||||
-rw-r--r-- | linux-core/drm_bo.c | 38 | ||||
-rw-r--r-- | linux-core/drm_bo_move.c | 2 | ||||
-rw-r--r-- | linux-core/drm_drv.c | 2 | ||||
-rw-r--r-- | linux-core/drm_memrange.c (renamed from linux-core/drm_mm.c) | 82 | ||||
-rw-r--r-- | linux-core/drm_objects.h | 6 | ||||
-rw-r--r-- | linux-core/drm_sman.c | 22 | ||||
-rw-r--r-- | linux-core/drm_sman.h | 4 | ||||
-rw-r--r-- | linux-core/drm_stub.c | 6 | ||||
-rw-r--r-- | linux-core/nouveau_bo.c | 2 | ||||
-rw-r--r-- | linux-core/nouveau_sgdma.c | 2 |
12 files changed, 108 insertions, 103 deletions
diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel index 093552bf..c4975924 100644 --- a/linux-core/Makefile.kernel +++ b/linux-core/Makefile.kernel | |||
@@ -12,7 +12,7 @@ drm-objs := drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.o \ | |||
12 | drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \ | 12 | drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \ |
13 | drm_sysfs.o drm_pci.o drm_agpsupport.o drm_scatter.o \ | 13 | drm_sysfs.o drm_pci.o drm_agpsupport.o drm_scatter.o \ |
14 | drm_memory_debug.o ati_pcigart.o drm_sman.o \ | 14 | drm_memory_debug.o ati_pcigart.o drm_sman.o \ |
15 | drm_hashtab.o drm_mm.o drm_object.o drm_compat.o \ | 15 | drm_hashtab.o drm_memrange.o drm_object.o drm_compat.o \ |
16 | drm_fence.o drm_ttm.o drm_bo.o drm_bo_move.o drm_bo_lock.o \ | 16 | drm_fence.o drm_ttm.o drm_bo.o drm_bo_move.o drm_bo_lock.o \ |
17 | drm_regman.o | 17 | drm_regman.o |
18 | tdfx-objs := tdfx_drv.o | 18 | tdfx-objs := tdfx_drv.o |
diff --git a/linux-core/drmP.h b/linux-core/drmP.h index 69d31e14..ea8a997f 100644 --- a/linux-core/drmP.h +++ b/linux-core/drmP.h | |||
@@ -539,17 +539,17 @@ struct drm_sigdata { | |||
539 | * Generic memory manager structs | 539 | * Generic memory manager structs |
540 | */ | 540 | */ |
541 | 541 | ||
542 | struct drm_mm_node { | 542 | struct drm_memrange_node { |
543 | struct list_head fl_entry; | 543 | struct list_head fl_entry; |
544 | struct list_head ml_entry; | 544 | struct list_head ml_entry; |
545 | int free; | 545 | int free; |
546 | unsigned long start; | 546 | unsigned long start; |
547 | unsigned long size; | 547 | unsigned long size; |
548 | struct drm_mm *mm; | 548 | struct drm_memrange *mm; |
549 | void *private; | 549 | void *private; |
550 | }; | 550 | }; |
551 | 551 | ||
552 | struct drm_mm { | 552 | struct drm_memrange { |
553 | struct list_head fl_entry; | 553 | struct list_head fl_entry; |
554 | struct list_head ml_entry; | 554 | struct list_head ml_entry; |
555 | }; | 555 | }; |
@@ -563,7 +563,7 @@ struct drm_map_list { | |||
563 | struct drm_hash_item hash; | 563 | struct drm_hash_item hash; |
564 | struct drm_map *map; /**< mapping */ | 564 | struct drm_map *map; /**< mapping */ |
565 | uint64_t user_token; | 565 | uint64_t user_token; |
566 | struct drm_mm_node *file_offset_node; | 566 | struct drm_memrange_node *file_offset_node; |
567 | }; | 567 | }; |
568 | 568 | ||
569 | typedef struct drm_map drm_local_map_t; | 569 | typedef struct drm_map drm_local_map_t; |
@@ -787,7 +787,7 @@ struct drm_device { | |||
787 | struct list_head maplist; /**< Linked list of regions */ | 787 | struct list_head maplist; /**< Linked list of regions */ |
788 | int map_count; /**< Number of mappable regions */ | 788 | int map_count; /**< Number of mappable regions */ |
789 | struct drm_open_hash map_hash; /**< User token hash table for maps */ | 789 | struct drm_open_hash map_hash; /**< User token hash table for maps */ |
790 | struct drm_mm offset_manager; /**< User token manager */ | 790 | struct drm_memrange offset_manager; /**< User token manager */ |
791 | struct drm_open_hash object_hash; /**< User token hash table for objects */ | 791 | struct drm_open_hash object_hash; /**< User token hash table for objects */ |
792 | struct address_space *dev_mapping; /**< For unmap_mapping_range() */ | 792 | struct address_space *dev_mapping; /**< For unmap_mapping_range() */ |
793 | struct page *ttm_dummy_page; | 793 | struct page *ttm_dummy_page; |
@@ -1234,22 +1234,27 @@ extern int drm_sysfs_device_add(struct drm_minor *minor); | |||
1234 | extern void drm_sysfs_device_remove(struct drm_minor *minor); | 1234 | extern void drm_sysfs_device_remove(struct drm_minor *minor); |
1235 | 1235 | ||
1236 | /* | 1236 | /* |
1237 | * Basic memory manager support (drm_mm.c) | 1237 | * Basic memory manager support (drm_memrange.c) |
1238 | */ | 1238 | */ |
1239 | 1239 | ||
1240 | extern struct drm_mm_node * drm_mm_get_block(struct drm_mm_node * parent, unsigned long size, | 1240 | extern struct drm_memrange_node *drm_memrange_get_block(struct drm_memrange_node * parent, |
1241 | unsigned alignment); | 1241 | unsigned long size, |
1242 | extern void drm_mm_put_block(struct drm_mm_node *cur); | 1242 | unsigned alignment); |
1243 | extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, unsigned long size, | 1243 | extern void drm_memrange_put_block(struct drm_memrange_node *cur); |
1244 | unsigned alignment, int best_match); | 1244 | extern struct drm_memrange_node *drm_memrange_search_free(const struct drm_memrange *mm, |
1245 | extern int drm_mm_init(struct drm_mm *mm, unsigned long start, unsigned long size); | 1245 | unsigned long size, |
1246 | extern void drm_mm_takedown(struct drm_mm *mm); | 1246 | unsigned alignment, int best_match); |
1247 | extern int drm_mm_clean(struct drm_mm *mm); | 1247 | extern int drm_memrange_init(struct drm_memrange *mm, |
1248 | extern unsigned long drm_mm_tail_space(struct drm_mm *mm); | 1248 | unsigned long start, unsigned long size); |
1249 | extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size); | 1249 | extern void drm_memrange_takedown(struct drm_memrange *mm); |
1250 | extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size); | 1250 | extern int drm_memrange_clean(struct drm_memrange *mm); |
1251 | 1251 | extern unsigned long drm_memrange_tail_space(struct drm_memrange *mm); | |
1252 | static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block) | 1252 | extern int drm_memrange_remove_space_from_tail(struct drm_memrange *mm, |
1253 | unsigned long size); | ||
1254 | extern int drm_memrange_add_space_to_tail(struct drm_memrange *mm, | ||
1255 | unsigned long size); | ||
1256 | |||
1257 | static inline struct drm_memrange *drm_get_mm(struct drm_memrange_node *block) | ||
1253 | { | 1258 | { |
1254 | return block->mm; | 1259 | return block->mm; |
1255 | } | 1260 | } |
diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c index 88b2ee66..3abbb8c4 100644 --- a/linux-core/drm_bo.c +++ b/linux-core/drm_bo.c | |||
@@ -418,14 +418,14 @@ static void drm_bo_cleanup_refs(struct drm_buffer_object *bo, int remove_all) | |||
418 | if (!bo->fence) { | 418 | if (!bo->fence) { |
419 | list_del_init(&bo->lru); | 419 | list_del_init(&bo->lru); |
420 | if (bo->mem.mm_node) { | 420 | if (bo->mem.mm_node) { |
421 | drm_mm_put_block(bo->mem.mm_node); | 421 | drm_memrange_put_block(bo->mem.mm_node); |
422 | if (bo->pinned_node == bo->mem.mm_node) | 422 | if (bo->pinned_node == bo->mem.mm_node) |
423 | bo->pinned_node = NULL; | 423 | bo->pinned_node = NULL; |
424 | bo->mem.mm_node = NULL; | 424 | bo->mem.mm_node = NULL; |
425 | } | 425 | } |
426 | list_del_init(&bo->pinned_lru); | 426 | list_del_init(&bo->pinned_lru); |
427 | if (bo->pinned_node) { | 427 | if (bo->pinned_node) { |
428 | drm_mm_put_block(bo->pinned_node); | 428 | drm_memrange_put_block(bo->pinned_node); |
429 | bo->pinned_node = NULL; | 429 | bo->pinned_node = NULL; |
430 | } | 430 | } |
431 | list_del_init(&bo->ddestroy); | 431 | list_del_init(&bo->ddestroy); |
@@ -791,7 +791,7 @@ out: | |||
791 | mutex_lock(&dev->struct_mutex); | 791 | mutex_lock(&dev->struct_mutex); |
792 | if (evict_mem.mm_node) { | 792 | if (evict_mem.mm_node) { |
793 | if (evict_mem.mm_node != bo->pinned_node) | 793 | if (evict_mem.mm_node != bo->pinned_node) |
794 | drm_mm_put_block(evict_mem.mm_node); | 794 | drm_memrange_put_block(evict_mem.mm_node); |
795 | evict_mem.mm_node = NULL; | 795 | evict_mem.mm_node = NULL; |
796 | } | 796 | } |
797 | drm_bo_add_to_lru(bo); | 797 | drm_bo_add_to_lru(bo); |
@@ -810,7 +810,7 @@ static int drm_bo_mem_force_space(struct drm_device *dev, | |||
810 | struct drm_bo_mem_reg *mem, | 810 | struct drm_bo_mem_reg *mem, |
811 | uint32_t mem_type, int no_wait) | 811 | uint32_t mem_type, int no_wait) |
812 | { | 812 | { |
813 | struct drm_mm_node *node; | 813 | struct drm_memrange_node *node; |
814 | struct drm_buffer_manager *bm = &dev->bm; | 814 | struct drm_buffer_manager *bm = &dev->bm; |
815 | struct drm_buffer_object *entry; | 815 | struct drm_buffer_object *entry; |
816 | struct drm_mem_type_manager *man = &bm->man[mem_type]; | 816 | struct drm_mem_type_manager *man = &bm->man[mem_type]; |
@@ -820,7 +820,7 @@ static int drm_bo_mem_force_space(struct drm_device *dev, | |||
820 | 820 | ||
821 | mutex_lock(&dev->struct_mutex); | 821 | mutex_lock(&dev->struct_mutex); |
822 | do { | 822 | do { |
823 | node = drm_mm_search_free(&man->manager, num_pages, | 823 | node = drm_memrange_search_free(&man->manager, num_pages, |
824 | mem->page_alignment, 1); | 824 | mem->page_alignment, 1); |
825 | if (node) | 825 | if (node) |
826 | break; | 826 | break; |
@@ -846,7 +846,7 @@ static int drm_bo_mem_force_space(struct drm_device *dev, | |||
846 | return -ENOMEM; | 846 | return -ENOMEM; |
847 | } | 847 | } |
848 | 848 | ||
849 | node = drm_mm_get_block(node, num_pages, mem->page_alignment); | 849 | node = drm_memrange_get_block(node, num_pages, mem->page_alignment); |
850 | if (unlikely(!node)) { | 850 | if (unlikely(!node)) { |
851 | mutex_unlock(&dev->struct_mutex); | 851 | mutex_unlock(&dev->struct_mutex); |
852 | return -ENOMEM; | 852 | return -ENOMEM; |
@@ -924,7 +924,7 @@ int drm_bo_mem_space(struct drm_buffer_object *bo, | |||
924 | int type_found = 0; | 924 | int type_found = 0; |
925 | int type_ok = 0; | 925 | int type_ok = 0; |
926 | int has_eagain = 0; | 926 | int has_eagain = 0; |
927 | struct drm_mm_node *node = NULL; | 927 | struct drm_memrange_node *node = NULL; |
928 | int ret; | 928 | int ret; |
929 | 929 | ||
930 | mem->mm_node = NULL; | 930 | mem->mm_node = NULL; |
@@ -952,10 +952,10 @@ int drm_bo_mem_space(struct drm_buffer_object *bo, | |||
952 | mutex_lock(&dev->struct_mutex); | 952 | mutex_lock(&dev->struct_mutex); |
953 | if (man->has_type && man->use_type) { | 953 | if (man->has_type && man->use_type) { |
954 | type_found = 1; | 954 | type_found = 1; |
955 | node = drm_mm_search_free(&man->manager, mem->num_pages, | 955 | node = drm_memrange_search_free(&man->manager, mem->num_pages, |
956 | mem->page_alignment, 1); | 956 | mem->page_alignment, 1); |
957 | if (node) | 957 | if (node) |
958 | node = drm_mm_get_block(node, mem->num_pages, | 958 | node = drm_memrange_get_block(node, mem->num_pages, |
959 | mem->page_alignment); | 959 | mem->page_alignment); |
960 | } | 960 | } |
961 | mutex_unlock(&dev->struct_mutex); | 961 | mutex_unlock(&dev->struct_mutex); |
@@ -1340,7 +1340,7 @@ out_unlock: | |||
1340 | if (ret || !move_unfenced) { | 1340 | if (ret || !move_unfenced) { |
1341 | if (mem.mm_node) { | 1341 | if (mem.mm_node) { |
1342 | if (mem.mm_node != bo->pinned_node) | 1342 | if (mem.mm_node != bo->pinned_node) |
1343 | drm_mm_put_block(mem.mm_node); | 1343 | drm_memrange_put_block(mem.mm_node); |
1344 | mem.mm_node = NULL; | 1344 | mem.mm_node = NULL; |
1345 | } | 1345 | } |
1346 | drm_bo_add_to_lru(bo); | 1346 | drm_bo_add_to_lru(bo); |
@@ -1432,7 +1432,7 @@ static int drm_buffer_object_validate(struct drm_buffer_object *bo, | |||
1432 | 1432 | ||
1433 | if (bo->pinned_node != bo->mem.mm_node) { | 1433 | if (bo->pinned_node != bo->mem.mm_node) { |
1434 | if (bo->pinned_node != NULL) | 1434 | if (bo->pinned_node != NULL) |
1435 | drm_mm_put_block(bo->pinned_node); | 1435 | drm_memrange_put_block(bo->pinned_node); |
1436 | bo->pinned_node = bo->mem.mm_node; | 1436 | bo->pinned_node = bo->mem.mm_node; |
1437 | } | 1437 | } |
1438 | 1438 | ||
@@ -1443,7 +1443,7 @@ static int drm_buffer_object_validate(struct drm_buffer_object *bo, | |||
1443 | mutex_lock(&dev->struct_mutex); | 1443 | mutex_lock(&dev->struct_mutex); |
1444 | 1444 | ||
1445 | if (bo->pinned_node != bo->mem.mm_node) | 1445 | if (bo->pinned_node != bo->mem.mm_node) |
1446 | drm_mm_put_block(bo->pinned_node); | 1446 | drm_memrange_put_block(bo->pinned_node); |
1447 | 1447 | ||
1448 | list_del_init(&bo->pinned_lru); | 1448 | list_del_init(&bo->pinned_lru); |
1449 | bo->pinned_node = NULL; | 1449 | bo->pinned_node = NULL; |
@@ -2082,7 +2082,7 @@ static int drm_bo_leave_list(struct drm_buffer_object *bo, | |||
2082 | if (bo->pinned_node == bo->mem.mm_node) | 2082 | if (bo->pinned_node == bo->mem.mm_node) |
2083 | bo->pinned_node = NULL; | 2083 | bo->pinned_node = NULL; |
2084 | if (bo->pinned_node != NULL) { | 2084 | if (bo->pinned_node != NULL) { |
2085 | drm_mm_put_block(bo->pinned_node); | 2085 | drm_memrange_put_block(bo->pinned_node); |
2086 | bo->pinned_node = NULL; | 2086 | bo->pinned_node = NULL; |
2087 | } | 2087 | } |
2088 | mutex_unlock(&dev->struct_mutex); | 2088 | mutex_unlock(&dev->struct_mutex); |
@@ -2223,8 +2223,8 @@ int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type, int kern_clean) | |||
2223 | drm_bo_force_list_clean(dev, &man->lru, mem_type, 1, 0, 0); | 2223 | drm_bo_force_list_clean(dev, &man->lru, mem_type, 1, 0, 0); |
2224 | drm_bo_force_list_clean(dev, &man->pinned, mem_type, 1, 0, 1); | 2224 | drm_bo_force_list_clean(dev, &man->pinned, mem_type, 1, 0, 1); |
2225 | 2225 | ||
2226 | if (drm_mm_clean(&man->manager)) { | 2226 | if (drm_memrange_clean(&man->manager)) { |
2227 | drm_mm_takedown(&man->manager); | 2227 | drm_memrange_takedown(&man->manager); |
2228 | } else { | 2228 | } else { |
2229 | ret = -EBUSY; | 2229 | ret = -EBUSY; |
2230 | } | 2230 | } |
@@ -2295,7 +2295,7 @@ int drm_bo_init_mm(struct drm_device *dev, unsigned type, | |||
2295 | DRM_ERROR("Zero size memory manager type %d\n", type); | 2295 | DRM_ERROR("Zero size memory manager type %d\n", type); |
2296 | return ret; | 2296 | return ret; |
2297 | } | 2297 | } |
2298 | ret = drm_mm_init(&man->manager, p_offset, p_size); | 2298 | ret = drm_memrange_init(&man->manager, p_offset, p_size); |
2299 | if (ret) | 2299 | if (ret) |
2300 | return ret; | 2300 | return ret; |
2301 | } | 2301 | } |
@@ -2713,7 +2713,7 @@ static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo) | |||
2713 | list->user_token = 0; | 2713 | list->user_token = 0; |
2714 | } | 2714 | } |
2715 | if (list->file_offset_node) { | 2715 | if (list->file_offset_node) { |
2716 | drm_mm_put_block(list->file_offset_node); | 2716 | drm_memrange_put_block(list->file_offset_node); |
2717 | list->file_offset_node = NULL; | 2717 | list->file_offset_node = NULL; |
2718 | } | 2718 | } |
2719 | 2719 | ||
@@ -2756,7 +2756,7 @@ static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo) | |||
2756 | atomic_inc(&bo->usage); | 2756 | atomic_inc(&bo->usage); |
2757 | map->handle = (void *)bo; | 2757 | map->handle = (void *)bo; |
2758 | 2758 | ||
2759 | list->file_offset_node = drm_mm_search_free(&dev->offset_manager, | 2759 | list->file_offset_node = drm_memrange_search_free(&dev->offset_manager, |
2760 | bo->mem.num_pages, 0, 0); | 2760 | bo->mem.num_pages, 0, 0); |
2761 | 2761 | ||
2762 | if (unlikely(!list->file_offset_node)) { | 2762 | if (unlikely(!list->file_offset_node)) { |
@@ -2764,7 +2764,7 @@ static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo) | |||
2764 | return -ENOMEM; | 2764 | return -ENOMEM; |
2765 | } | 2765 | } |
2766 | 2766 | ||
2767 | list->file_offset_node = drm_mm_get_block(list->file_offset_node, | 2767 | list->file_offset_node = drm_memrange_get_block(list->file_offset_node, |
2768 | bo->mem.num_pages, 0); | 2768 | bo->mem.num_pages, 0); |
2769 | 2769 | ||
2770 | if (unlikely(!list->file_offset_node)) { | 2770 | if (unlikely(!list->file_offset_node)) { |
diff --git a/linux-core/drm_bo_move.c b/linux-core/drm_bo_move.c index bf0e1b74..850be5a3 100644 --- a/linux-core/drm_bo_move.c +++ b/linux-core/drm_bo_move.c | |||
@@ -41,7 +41,7 @@ static void drm_bo_free_old_node(struct drm_buffer_object *bo) | |||
41 | 41 | ||
42 | if (old_mem->mm_node && (old_mem->mm_node != bo->pinned_node)) { | 42 | if (old_mem->mm_node && (old_mem->mm_node != bo->pinned_node)) { |
43 | mutex_lock(&bo->dev->struct_mutex); | 43 | mutex_lock(&bo->dev->struct_mutex); |
44 | drm_mm_put_block(old_mem->mm_node); | 44 | drm_memrange_put_block(old_mem->mm_node); |
45 | mutex_unlock(&bo->dev->struct_mutex); | 45 | mutex_unlock(&bo->dev->struct_mutex); |
46 | } | 46 | } |
47 | old_mem->mm_node = NULL; | 47 | old_mem->mm_node = NULL; |
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c index b8b8333e..b5bd3616 100644 --- a/linux-core/drm_drv.c +++ b/linux-core/drm_drv.c | |||
@@ -415,7 +415,7 @@ static void drm_cleanup(struct drm_device * dev) | |||
415 | 415 | ||
416 | drm_ctxbitmap_cleanup(dev); | 416 | drm_ctxbitmap_cleanup(dev); |
417 | drm_ht_remove(&dev->map_hash); | 417 | drm_ht_remove(&dev->map_hash); |
418 | drm_mm_takedown(&dev->offset_manager); | 418 | drm_memrange_takedown(&dev->offset_manager); |
419 | drm_ht_remove(&dev->object_hash); | 419 | drm_ht_remove(&dev->object_hash); |
420 | 420 | ||
421 | drm_put_minor(&dev->primary); | 421 | drm_put_minor(&dev->primary); |
diff --git a/linux-core/drm_mm.c b/linux-core/drm_memrange.c index 59110293..0ae03655 100644 --- a/linux-core/drm_mm.c +++ b/linux-core/drm_memrange.c | |||
@@ -44,26 +44,26 @@ | |||
44 | #include "drmP.h" | 44 | #include "drmP.h" |
45 | #include <linux/slab.h> | 45 | #include <linux/slab.h> |
46 | 46 | ||
47 | unsigned long drm_mm_tail_space(struct drm_mm *mm) | 47 | unsigned long drm_memrange_tail_space(struct drm_memrange *mm) |
48 | { | 48 | { |
49 | struct list_head *tail_node; | 49 | struct list_head *tail_node; |
50 | struct drm_mm_node *entry; | 50 | struct drm_memrange_node *entry; |
51 | 51 | ||
52 | tail_node = mm->ml_entry.prev; | 52 | tail_node = mm->ml_entry.prev; |
53 | entry = list_entry(tail_node, struct drm_mm_node, ml_entry); | 53 | entry = list_entry(tail_node, struct drm_memrange_node, ml_entry); |
54 | if (!entry->free) | 54 | if (!entry->free) |
55 | return 0; | 55 | return 0; |
56 | 56 | ||
57 | return entry->size; | 57 | return entry->size; |
58 | } | 58 | } |
59 | 59 | ||
60 | int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size) | 60 | int drm_memrange_remove_space_from_tail(struct drm_memrange *mm, unsigned long size) |
61 | { | 61 | { |
62 | struct list_head *tail_node; | 62 | struct list_head *tail_node; |
63 | struct drm_mm_node *entry; | 63 | struct drm_memrange_node *entry; |
64 | 64 | ||
65 | tail_node = mm->ml_entry.prev; | 65 | tail_node = mm->ml_entry.prev; |
66 | entry = list_entry(tail_node, struct drm_mm_node, ml_entry); | 66 | entry = list_entry(tail_node, struct drm_memrange_node, ml_entry); |
67 | if (!entry->free) | 67 | if (!entry->free) |
68 | return -ENOMEM; | 68 | return -ENOMEM; |
69 | 69 | ||
@@ -75,13 +75,13 @@ int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size) | |||
75 | } | 75 | } |
76 | 76 | ||
77 | 77 | ||
78 | static int drm_mm_create_tail_node(struct drm_mm *mm, | 78 | static int drm_memrange_create_tail_node(struct drm_memrange *mm, |
79 | unsigned long start, | 79 | unsigned long start, |
80 | unsigned long size) | 80 | unsigned long size) |
81 | { | 81 | { |
82 | struct drm_mm_node *child; | 82 | struct drm_memrange_node *child; |
83 | 83 | ||
84 | child = (struct drm_mm_node *) | 84 | child = (struct drm_memrange_node *) |
85 | drm_ctl_alloc(sizeof(*child), DRM_MEM_MM); | 85 | drm_ctl_alloc(sizeof(*child), DRM_MEM_MM); |
86 | if (!child) | 86 | if (!child) |
87 | return -ENOMEM; | 87 | return -ENOMEM; |
@@ -98,26 +98,26 @@ static int drm_mm_create_tail_node(struct drm_mm *mm, | |||
98 | } | 98 | } |
99 | 99 | ||
100 | 100 | ||
101 | int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size) | 101 | int drm_memrange_add_space_to_tail(struct drm_memrange *mm, unsigned long size) |
102 | { | 102 | { |
103 | struct list_head *tail_node; | 103 | struct list_head *tail_node; |
104 | struct drm_mm_node *entry; | 104 | struct drm_memrange_node *entry; |
105 | 105 | ||
106 | tail_node = mm->ml_entry.prev; | 106 | tail_node = mm->ml_entry.prev; |
107 | entry = list_entry(tail_node, struct drm_mm_node, ml_entry); | 107 | entry = list_entry(tail_node, struct drm_memrange_node, ml_entry); |
108 | if (!entry->free) { | 108 | if (!entry->free) { |
109 | return drm_mm_create_tail_node(mm, entry->start + entry->size, size); | 109 | return drm_memrange_create_tail_node(mm, entry->start + entry->size, size); |
110 | } | 110 | } |
111 | entry->size += size; | 111 | entry->size += size; |
112 | return 0; | 112 | return 0; |
113 | } | 113 | } |
114 | 114 | ||
115 | static struct drm_mm_node *drm_mm_split_at_start(struct drm_mm_node *parent, | 115 | static struct drm_memrange_node *drm_memrange_split_at_start(struct drm_memrange_node *parent, |
116 | unsigned long size) | 116 | unsigned long size) |
117 | { | 117 | { |
118 | struct drm_mm_node *child; | 118 | struct drm_memrange_node *child; |
119 | 119 | ||
120 | child = (struct drm_mm_node *) | 120 | child = (struct drm_memrange_node *) |
121 | drm_ctl_alloc(sizeof(*child), DRM_MEM_MM); | 121 | drm_ctl_alloc(sizeof(*child), DRM_MEM_MM); |
122 | if (!child) | 122 | if (!child) |
123 | return NULL; | 123 | return NULL; |
@@ -137,19 +137,19 @@ static struct drm_mm_node *drm_mm_split_at_start(struct drm_mm_node *parent, | |||
137 | return child; | 137 | return child; |
138 | } | 138 | } |
139 | 139 | ||
140 | struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent, | 140 | struct drm_memrange_node *drm_memrange_get_block(struct drm_memrange_node * parent, |
141 | unsigned long size, unsigned alignment) | 141 | unsigned long size, unsigned alignment) |
142 | { | 142 | { |
143 | 143 | ||
144 | struct drm_mm_node *align_splitoff = NULL; | 144 | struct drm_memrange_node *align_splitoff = NULL; |
145 | struct drm_mm_node *child; | 145 | struct drm_memrange_node *child; |
146 | unsigned tmp = 0; | 146 | unsigned tmp = 0; |
147 | 147 | ||
148 | if (alignment) | 148 | if (alignment) |
149 | tmp = parent->start % alignment; | 149 | tmp = parent->start % alignment; |
150 | 150 | ||
151 | if (tmp) { | 151 | if (tmp) { |
152 | align_splitoff = drm_mm_split_at_start(parent, alignment - tmp); | 152 | align_splitoff = drm_memrange_split_at_start(parent, alignment - tmp); |
153 | if (!align_splitoff) | 153 | if (!align_splitoff) |
154 | return NULL; | 154 | return NULL; |
155 | } | 155 | } |
@@ -159,11 +159,11 @@ struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent, | |||
159 | parent->free = 0; | 159 | parent->free = 0; |
160 | return parent; | 160 | return parent; |
161 | } else { | 161 | } else { |
162 | child = drm_mm_split_at_start(parent, size); | 162 | child = drm_memrange_split_at_start(parent, size); |
163 | } | 163 | } |
164 | 164 | ||
165 | if (align_splitoff) | 165 | if (align_splitoff) |
166 | drm_mm_put_block(align_splitoff); | 166 | drm_memrange_put_block(align_splitoff); |
167 | 167 | ||
168 | return child; | 168 | return child; |
169 | } | 169 | } |
@@ -173,26 +173,26 @@ struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent, | |||
173 | * Otherwise add to the free stack. | 173 | * Otherwise add to the free stack. |
174 | */ | 174 | */ |
175 | 175 | ||
176 | void drm_mm_put_block(struct drm_mm_node * cur) | 176 | void drm_memrange_put_block(struct drm_memrange_node * cur) |
177 | { | 177 | { |
178 | 178 | ||
179 | struct drm_mm *mm = cur->mm; | 179 | struct drm_memrange *mm = cur->mm; |
180 | struct list_head *cur_head = &cur->ml_entry; | 180 | struct list_head *cur_head = &cur->ml_entry; |
181 | struct list_head *root_head = &mm->ml_entry; | 181 | struct list_head *root_head = &mm->ml_entry; |
182 | struct drm_mm_node *prev_node = NULL; | 182 | struct drm_memrange_node *prev_node = NULL; |
183 | struct drm_mm_node *next_node; | 183 | struct drm_memrange_node *next_node; |
184 | 184 | ||
185 | int merged = 0; | 185 | int merged = 0; |
186 | 186 | ||
187 | if (cur_head->prev != root_head) { | 187 | if (cur_head->prev != root_head) { |
188 | prev_node = list_entry(cur_head->prev, struct drm_mm_node, ml_entry); | 188 | prev_node = list_entry(cur_head->prev, struct drm_memrange_node, ml_entry); |
189 | if (prev_node->free) { | 189 | if (prev_node->free) { |
190 | prev_node->size += cur->size; | 190 | prev_node->size += cur->size; |
191 | merged = 1; | 191 | merged = 1; |
192 | } | 192 | } |
193 | } | 193 | } |
194 | if (cur_head->next != root_head) { | 194 | if (cur_head->next != root_head) { |
195 | next_node = list_entry(cur_head->next, struct drm_mm_node, ml_entry); | 195 | next_node = list_entry(cur_head->next, struct drm_memrange_node, ml_entry); |
196 | if (next_node->free) { | 196 | if (next_node->free) { |
197 | if (merged) { | 197 | if (merged) { |
198 | prev_node->size += next_node->size; | 198 | prev_node->size += next_node->size; |
@@ -215,16 +215,16 @@ void drm_mm_put_block(struct drm_mm_node * cur) | |||
215 | drm_ctl_free(cur, sizeof(*cur), DRM_MEM_MM); | 215 | drm_ctl_free(cur, sizeof(*cur), DRM_MEM_MM); |
216 | } | 216 | } |
217 | } | 217 | } |
218 | EXPORT_SYMBOL(drm_mm_put_block); | 218 | EXPORT_SYMBOL(drm_memrange_put_block); |
219 | 219 | ||
220 | struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm, | 220 | struct drm_memrange_node *drm_memrange_search_free(const struct drm_memrange * mm, |
221 | unsigned long size, | 221 | unsigned long size, |
222 | unsigned alignment, int best_match) | 222 | unsigned alignment, int best_match) |
223 | { | 223 | { |
224 | struct list_head *list; | 224 | struct list_head *list; |
225 | const struct list_head *free_stack = &mm->fl_entry; | 225 | const struct list_head *free_stack = &mm->fl_entry; |
226 | struct drm_mm_node *entry; | 226 | struct drm_memrange_node *entry; |
227 | struct drm_mm_node *best; | 227 | struct drm_memrange_node *best; |
228 | unsigned long best_size; | 228 | unsigned long best_size; |
229 | unsigned wasted; | 229 | unsigned wasted; |
230 | 230 | ||
@@ -232,7 +232,7 @@ struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm, | |||
232 | best_size = ~0UL; | 232 | best_size = ~0UL; |
233 | 233 | ||
234 | list_for_each(list, free_stack) { | 234 | list_for_each(list, free_stack) { |
235 | entry = list_entry(list, struct drm_mm_node, fl_entry); | 235 | entry = list_entry(list, struct drm_memrange_node, fl_entry); |
236 | wasted = 0; | 236 | wasted = 0; |
237 | 237 | ||
238 | if (entry->size < size) | 238 | if (entry->size < size) |
@@ -258,29 +258,29 @@ struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm, | |||
258 | return best; | 258 | return best; |
259 | } | 259 | } |
260 | 260 | ||
261 | int drm_mm_clean(struct drm_mm * mm) | 261 | int drm_memrange_clean(struct drm_memrange * mm) |
262 | { | 262 | { |
263 | struct list_head *head = &mm->ml_entry; | 263 | struct list_head *head = &mm->ml_entry; |
264 | 264 | ||
265 | return (head->next->next == head); | 265 | return (head->next->next == head); |
266 | } | 266 | } |
267 | 267 | ||
268 | int drm_mm_init(struct drm_mm * mm, unsigned long start, unsigned long size) | 268 | int drm_memrange_init(struct drm_memrange * mm, unsigned long start, unsigned long size) |
269 | { | 269 | { |
270 | INIT_LIST_HEAD(&mm->ml_entry); | 270 | INIT_LIST_HEAD(&mm->ml_entry); |
271 | INIT_LIST_HEAD(&mm->fl_entry); | 271 | INIT_LIST_HEAD(&mm->fl_entry); |
272 | 272 | ||
273 | return drm_mm_create_tail_node(mm, start, size); | 273 | return drm_memrange_create_tail_node(mm, start, size); |
274 | } | 274 | } |
275 | 275 | ||
276 | EXPORT_SYMBOL(drm_mm_init); | 276 | EXPORT_SYMBOL(drm_memrange_init); |
277 | 277 | ||
278 | void drm_mm_takedown(struct drm_mm * mm) | 278 | void drm_memrange_takedown(struct drm_memrange * mm) |
279 | { | 279 | { |
280 | struct list_head *bnode = mm->fl_entry.next; | 280 | struct list_head *bnode = mm->fl_entry.next; |
281 | struct drm_mm_node *entry; | 281 | struct drm_memrange_node *entry; |
282 | 282 | ||
283 | entry = list_entry(bnode, struct drm_mm_node, fl_entry); | 283 | entry = list_entry(bnode, struct drm_memrange_node, fl_entry); |
284 | 284 | ||
285 | if (entry->ml_entry.next != &mm->ml_entry || | 285 | if (entry->ml_entry.next != &mm->ml_entry || |
286 | entry->fl_entry.next != &mm->fl_entry) { | 286 | entry->fl_entry.next != &mm->fl_entry) { |
@@ -293,4 +293,4 @@ void drm_mm_takedown(struct drm_mm * mm) | |||
293 | drm_ctl_free(entry, sizeof(*entry), DRM_MEM_MM); | 293 | drm_ctl_free(entry, sizeof(*entry), DRM_MEM_MM); |
294 | } | 294 | } |
295 | 295 | ||
296 | EXPORT_SYMBOL(drm_mm_takedown); | 296 | EXPORT_SYMBOL(drm_memrange_takedown); |
diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h index 6a900612..6ec09ef8 100644 --- a/linux-core/drm_objects.h +++ b/linux-core/drm_objects.h | |||
@@ -418,7 +418,7 @@ extern int drm_ttm_destroy(struct drm_ttm *ttm); | |||
418 | */ | 418 | */ |
419 | 419 | ||
420 | struct drm_bo_mem_reg { | 420 | struct drm_bo_mem_reg { |
421 | struct drm_mm_node *mm_node; | 421 | struct drm_memrange_node *mm_node; |
422 | unsigned long size; | 422 | unsigned long size; |
423 | unsigned long num_pages; | 423 | unsigned long num_pages; |
424 | uint32_t page_alignment; | 424 | uint32_t page_alignment; |
@@ -499,7 +499,7 @@ struct drm_buffer_object { | |||
499 | unsigned long num_pages; | 499 | unsigned long num_pages; |
500 | 500 | ||
501 | /* For pinned buffers */ | 501 | /* For pinned buffers */ |
502 | struct drm_mm_node *pinned_node; | 502 | struct drm_memrange_node *pinned_node; |
503 | uint32_t pinned_mem_type; | 503 | uint32_t pinned_mem_type; |
504 | struct list_head pinned_lru; | 504 | struct list_head pinned_lru; |
505 | 505 | ||
@@ -534,7 +534,7 @@ struct drm_mem_type_manager { | |||
534 | int has_type; | 534 | int has_type; |
535 | int use_type; | 535 | int use_type; |
536 | int kern_init_type; | 536 | int kern_init_type; |
537 | struct drm_mm manager; | 537 | struct drm_memrange manager; |
538 | struct list_head lru; | 538 | struct list_head lru; |
539 | struct list_head pinned; | 539 | struct list_head pinned; |
540 | uint32_t flags; | 540 | uint32_t flags; |
diff --git a/linux-core/drm_sman.c b/linux-core/drm_sman.c index 8421a939..7c16f685 100644 --- a/linux-core/drm_sman.c +++ b/linux-core/drm_sman.c | |||
@@ -88,34 +88,34 @@ EXPORT_SYMBOL(drm_sman_init); | |||
88 | static void *drm_sman_mm_allocate(void *private, unsigned long size, | 88 | static void *drm_sman_mm_allocate(void *private, unsigned long size, |
89 | unsigned alignment) | 89 | unsigned alignment) |
90 | { | 90 | { |
91 | struct drm_mm *mm = (struct drm_mm *) private; | 91 | struct drm_memrange *mm = (struct drm_memrange *) private; |
92 | struct drm_mm_node *tmp; | 92 | struct drm_memrange_node *tmp; |
93 | 93 | ||
94 | tmp = drm_mm_search_free(mm, size, alignment, 1); | 94 | tmp = drm_memrange_search_free(mm, size, alignment, 1); |
95 | if (!tmp) { | 95 | if (!tmp) { |
96 | return NULL; | 96 | return NULL; |
97 | } | 97 | } |
98 | tmp = drm_mm_get_block(tmp, size, alignment); | 98 | tmp = drm_memrange_get_block(tmp, size, alignment); |
99 | return tmp; | 99 | return tmp; |
100 | } | 100 | } |
101 | 101 | ||
102 | static void drm_sman_mm_free(void *private, void *ref) | 102 | static void drm_sman_mm_free(void *private, void *ref) |
103 | { | 103 | { |
104 | struct drm_mm_node *node = (struct drm_mm_node *) ref; | 104 | struct drm_memrange_node *node = (struct drm_memrange_node *) ref; |
105 | 105 | ||
106 | drm_mm_put_block(node); | 106 | drm_memrange_put_block(node); |
107 | } | 107 | } |
108 | 108 | ||
109 | static void drm_sman_mm_destroy(void *private) | 109 | static void drm_sman_mm_destroy(void *private) |
110 | { | 110 | { |
111 | struct drm_mm *mm = (struct drm_mm *) private; | 111 | struct drm_memrange *mm = (struct drm_memrange *) private; |
112 | drm_mm_takedown(mm); | 112 | drm_memrange_takedown(mm); |
113 | drm_free(mm, sizeof(*mm), DRM_MEM_MM); | 113 | drm_free(mm, sizeof(*mm), DRM_MEM_MM); |
114 | } | 114 | } |
115 | 115 | ||
116 | static unsigned long drm_sman_mm_offset(void *private, void *ref) | 116 | static unsigned long drm_sman_mm_offset(void *private, void *ref) |
117 | { | 117 | { |
118 | struct drm_mm_node *node = (struct drm_mm_node *) ref; | 118 | struct drm_memrange_node *node = (struct drm_memrange_node *) ref; |
119 | return node->start; | 119 | return node->start; |
120 | } | 120 | } |
121 | 121 | ||
@@ -124,7 +124,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager, | |||
124 | unsigned long start, unsigned long size) | 124 | unsigned long start, unsigned long size) |
125 | { | 125 | { |
126 | struct drm_sman_mm *sman_mm; | 126 | struct drm_sman_mm *sman_mm; |
127 | struct drm_mm *mm; | 127 | struct drm_memrange *mm; |
128 | int ret; | 128 | int ret; |
129 | 129 | ||
130 | BUG_ON(manager >= sman->num_managers); | 130 | BUG_ON(manager >= sman->num_managers); |
@@ -135,7 +135,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager, | |||
135 | return -ENOMEM; | 135 | return -ENOMEM; |
136 | } | 136 | } |
137 | sman_mm->private = mm; | 137 | sman_mm->private = mm; |
138 | ret = drm_mm_init(mm, start, size); | 138 | ret = drm_memrange_init(mm, start, size); |
139 | 139 | ||
140 | if (ret) { | 140 | if (ret) { |
141 | drm_free(mm, sizeof(*mm), DRM_MEM_MM); | 141 | drm_free(mm, sizeof(*mm), DRM_MEM_MM); |
diff --git a/linux-core/drm_sman.h b/linux-core/drm_sman.h index 39a39fef..0299776c 100644 --- a/linux-core/drm_sman.h +++ b/linux-core/drm_sman.h | |||
@@ -45,7 +45,7 @@ | |||
45 | /* | 45 | /* |
46 | * A class that is an abstration of a simple memory allocator. | 46 | * A class that is an abstration of a simple memory allocator. |
47 | * The sman implementation provides a default such allocator | 47 | * The sman implementation provides a default such allocator |
48 | * using the drm_mm.c implementation. But the user can replace it. | 48 | * using the drm_memrange.c implementation. But the user can replace it. |
49 | * See the SiS implementation, which may use the SiS FB kernel module | 49 | * See the SiS implementation, which may use the SiS FB kernel module |
50 | * for memory management. | 50 | * for memory management. |
51 | */ | 51 | */ |
@@ -116,7 +116,7 @@ extern int drm_sman_init(struct drm_sman * sman, unsigned int num_managers, | |||
116 | unsigned int user_order, unsigned int owner_order); | 116 | unsigned int user_order, unsigned int owner_order); |
117 | 117 | ||
118 | /* | 118 | /* |
119 | * Initialize a drm_mm.c allocator. Should be called only once for each | 119 | * Initialize a drm_memrange.c allocator. Should be called only once for each |
120 | * manager unless a customized allogator is used. | 120 | * manager unless a customized allogator is used. |
121 | */ | 121 | */ |
122 | 122 | ||
diff --git a/linux-core/drm_stub.c b/linux-core/drm_stub.c index c68adbaf..030fea54 100644 --- a/linux-core/drm_stub.c +++ b/linux-core/drm_stub.c | |||
@@ -115,15 +115,15 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev, | |||
115 | if (drm_ht_create(&dev->map_hash, DRM_MAP_HASH_ORDER)) { | 115 | if (drm_ht_create(&dev->map_hash, DRM_MAP_HASH_ORDER)) { |
116 | return -ENOMEM; | 116 | return -ENOMEM; |
117 | } | 117 | } |
118 | if (drm_mm_init(&dev->offset_manager, DRM_FILE_PAGE_OFFSET_START, | 118 | if (drm_memrange_init(&dev->offset_manager, DRM_FILE_PAGE_OFFSET_START, |
119 | DRM_FILE_PAGE_OFFSET_SIZE)) { | 119 | DRM_FILE_PAGE_OFFSET_SIZE)) { |
120 | drm_ht_remove(&dev->map_hash); | 120 | drm_ht_remove(&dev->map_hash); |
121 | return -ENOMEM; | 121 | return -ENOMEM; |
122 | } | 122 | } |
123 | 123 | ||
124 | if (drm_ht_create(&dev->object_hash, DRM_OBJECT_HASH_ORDER)) { | 124 | if (drm_ht_create(&dev->object_hash, DRM_OBJECT_HASH_ORDER)) { |
125 | drm_ht_remove(&dev->map_hash); | 125 | drm_ht_remove(&dev->map_hash); |
126 | drm_mm_takedown(&dev->offset_manager); | 126 | drm_memrange_takedown(&dev->offset_manager); |
127 | return -ENOMEM; | 127 | return -ENOMEM; |
128 | } | 128 | } |
129 | 129 | ||
diff --git a/linux-core/nouveau_bo.c b/linux-core/nouveau_bo.c index ab3b23a4..86347e03 100644 --- a/linux-core/nouveau_bo.c +++ b/linux-core/nouveau_bo.c | |||
@@ -229,7 +229,7 @@ out_cleanup: | |||
229 | if (tmp_mem.mm_node) { | 229 | if (tmp_mem.mm_node) { |
230 | mutex_lock(&dev->struct_mutex); | 230 | mutex_lock(&dev->struct_mutex); |
231 | if (tmp_mem.mm_node != bo->pinned_node) | 231 | if (tmp_mem.mm_node != bo->pinned_node) |
232 | drm_mm_put_block(tmp_mem.mm_node); | 232 | drm_memrange_put_block(tmp_mem.mm_node); |
233 | tmp_mem.mm_node = NULL; | 233 | tmp_mem.mm_node = NULL; |
234 | mutex_unlock(&dev->struct_mutex); | 234 | mutex_unlock(&dev->struct_mutex); |
235 | } | 235 | } |
diff --git a/linux-core/nouveau_sgdma.c b/linux-core/nouveau_sgdma.c index cc4d5a92..81704ea1 100644 --- a/linux-core/nouveau_sgdma.c +++ b/linux-core/nouveau_sgdma.c | |||
@@ -280,7 +280,7 @@ nouveau_sgdma_nottm_hack_init(struct drm_device *dev) | |||
280 | struct drm_nouveau_private *dev_priv = dev->dev_private; | 280 | struct drm_nouveau_private *dev_priv = dev->dev_private; |
281 | struct drm_ttm_backend *be; | 281 | struct drm_ttm_backend *be; |
282 | struct drm_scatter_gather sgreq; | 282 | struct drm_scatter_gather sgreq; |
283 | struct drm_mm_node mm_node; | 283 | struct drm_memrange_node mm_node; |
284 | struct drm_bo_mem_reg mem; | 284 | struct drm_bo_mem_reg mem; |
285 | int ret; | 285 | int ret; |
286 | 286 | ||