2 * Copyright 2020 Advanced Micro Devices, Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
22 * Authors: Christian König
25 #include <linux/iosys-map.h>
26 #include <linux/io-mapping.h>
27 #include <linux/scatterlist.h>
29 #include <drm/ttm/ttm_bo.h>
30 #include <drm/ttm/ttm_placement.h>
31 #include <drm/ttm/ttm_resource.h>
34 * ttm_lru_bulk_move_init - initialize a bulk move structure
35 * @bulk: the structure to init
37 * For now just memset the structure to zero.
39 void ttm_lru_bulk_move_init(struct ttm_lru_bulk_move *bulk)
41 memset(bulk, 0, sizeof(*bulk));
43 EXPORT_SYMBOL(ttm_lru_bulk_move_init);
46 * ttm_lru_bulk_move_tail - bulk move range of resources to the LRU tail.
48 * @bulk: bulk move structure
50 * Bulk move BOs to the LRU tail, only valid to use when driver makes sure that
51 * resource order never changes. Should be called with &ttm_device.lru_lock held.
53 void ttm_lru_bulk_move_tail(struct ttm_lru_bulk_move *bulk)
57 for (i = 0; i < TTM_NUM_MEM_TYPES; ++i) {
58 for (j = 0; j < TTM_MAX_BO_PRIORITY; ++j) {
59 struct ttm_lru_bulk_move_pos *pos = &bulk->pos[i][j];
60 struct ttm_resource_manager *man;
65 lockdep_assert_held(&pos->first->bo->bdev->lru_lock);
66 dma_resv_assert_held(pos->first->bo->base.resv);
67 dma_resv_assert_held(pos->last->bo->base.resv);
69 man = ttm_manager_type(pos->first->bo->bdev, i);
70 list_bulk_move_tail(&man->lru[j], &pos->first->lru,
75 EXPORT_SYMBOL(ttm_lru_bulk_move_tail);
77 /* Return the bulk move pos object for this resource */
78 static struct ttm_lru_bulk_move_pos *
79 ttm_lru_bulk_move_pos(struct ttm_lru_bulk_move *bulk, struct ttm_resource *res)
81 return &bulk->pos[res->mem_type][res->bo->priority];
84 /* Move the resource to the tail of the bulk move range */
85 static void ttm_lru_bulk_move_pos_tail(struct ttm_lru_bulk_move_pos *pos,
86 struct ttm_resource *res)
88 if (pos->last != res) {
89 list_move(&res->lru, &pos->last->lru);
94 /* Add the resource to a bulk_move cursor */
95 static void ttm_lru_bulk_move_add(struct ttm_lru_bulk_move *bulk,
96 struct ttm_resource *res)
98 struct ttm_lru_bulk_move_pos *pos = ttm_lru_bulk_move_pos(bulk, res);
104 ttm_lru_bulk_move_pos_tail(pos, res);
108 /* Remove the resource from a bulk_move range */
109 static void ttm_lru_bulk_move_del(struct ttm_lru_bulk_move *bulk,
110 struct ttm_resource *res)
112 struct ttm_lru_bulk_move_pos *pos = ttm_lru_bulk_move_pos(bulk, res);
114 if (unlikely(pos->first == res && pos->last == res)) {
117 } else if (pos->first == res) {
118 pos->first = list_next_entry(res, lru);
119 } else if (pos->last == res) {
120 pos->last = list_prev_entry(res, lru);
122 list_move(&res->lru, &pos->last->lru);
126 /* Add the resource to a bulk move if the BO is configured for it */
127 void ttm_resource_add_bulk_move(struct ttm_resource *res,
128 struct ttm_buffer_object *bo)
130 if (bo->bulk_move && !bo->pin_count)
131 ttm_lru_bulk_move_add(bo->bulk_move, res);
134 /* Remove the resource from a bulk move if the BO is configured for it */
135 void ttm_resource_del_bulk_move(struct ttm_resource *res,
136 struct ttm_buffer_object *bo)
138 if (bo->bulk_move && !bo->pin_count)
139 ttm_lru_bulk_move_del(bo->bulk_move, res);
142 /* Move a resource to the LRU or bulk tail */
143 void ttm_resource_move_to_lru_tail(struct ttm_resource *res)
145 struct ttm_buffer_object *bo = res->bo;
146 struct ttm_device *bdev = bo->bdev;
148 lockdep_assert_held(&bo->bdev->lru_lock);
151 list_move_tail(&res->lru, &bdev->pinned);
153 } else if (bo->bulk_move) {
154 struct ttm_lru_bulk_move_pos *pos =
155 ttm_lru_bulk_move_pos(bo->bulk_move, res);
157 ttm_lru_bulk_move_pos_tail(pos, res);
159 struct ttm_resource_manager *man;
161 man = ttm_manager_type(bdev, res->mem_type);
162 list_move_tail(&res->lru, &man->lru[bo->priority]);
167 * ttm_resource_init - resource object constructure
168 * @bo: buffer object this resources is allocated for
169 * @place: placement of the resource
170 * @res: the resource object to inistilize
172 * Initialize a new resource object. Counterpart of ttm_resource_fini().
174 void ttm_resource_init(struct ttm_buffer_object *bo,
175 const struct ttm_place *place,
176 struct ttm_resource *res)
178 struct ttm_resource_manager *man;
181 res->size = bo->base.size;
182 res->mem_type = place->mem_type;
183 res->placement = place->flags;
184 res->bus.addr = NULL;
186 res->bus.is_iomem = false;
187 res->bus.caching = ttm_cached;
190 man = ttm_manager_type(bo->bdev, place->mem_type);
191 spin_lock(&bo->bdev->lru_lock);
193 list_add_tail(&res->lru, &bo->bdev->pinned);
195 list_add_tail(&res->lru, &man->lru[bo->priority]);
196 man->usage += res->size;
197 spin_unlock(&bo->bdev->lru_lock);
199 EXPORT_SYMBOL(ttm_resource_init);
202 * ttm_resource_fini - resource destructor
203 * @man: the resource manager this resource belongs to
204 * @res: the resource to clean up
206 * Should be used by resource manager backends to clean up the TTM resource
207 * objects before freeing the underlying structure. Makes sure the resource is
208 * removed from the LRU before destruction.
209 * Counterpart of ttm_resource_init().
211 void ttm_resource_fini(struct ttm_resource_manager *man,
212 struct ttm_resource *res)
214 struct ttm_device *bdev = man->bdev;
216 spin_lock(&bdev->lru_lock);
217 list_del_init(&res->lru);
218 man->usage -= res->size;
219 spin_unlock(&bdev->lru_lock);
221 EXPORT_SYMBOL(ttm_resource_fini);
223 int ttm_resource_alloc(struct ttm_buffer_object *bo,
224 const struct ttm_place *place,
225 struct ttm_resource **res_ptr)
227 struct ttm_resource_manager *man =
228 ttm_manager_type(bo->bdev, place->mem_type);
231 ret = man->func->alloc(man, bo, place, res_ptr);
235 spin_lock(&bo->bdev->lru_lock);
236 ttm_resource_add_bulk_move(*res_ptr, bo);
237 spin_unlock(&bo->bdev->lru_lock);
241 void ttm_resource_free(struct ttm_buffer_object *bo, struct ttm_resource **res)
243 struct ttm_resource_manager *man;
248 spin_lock(&bo->bdev->lru_lock);
249 ttm_resource_del_bulk_move(*res, bo);
250 spin_unlock(&bo->bdev->lru_lock);
251 man = ttm_manager_type(bo->bdev, (*res)->mem_type);
252 man->func->free(man, *res);
255 EXPORT_SYMBOL(ttm_resource_free);
258 * ttm_resource_intersects - test for intersection
260 * @bdev: TTM device structure
261 * @res: The resource to test
262 * @place: The placement to test
263 * @size: How many bytes the new allocation needs.
265 * Test if @res intersects with @place and @size. Used for testing if evictions
266 * are valueable or not.
268 * Returns true if the res placement intersects with @place and @size.
270 bool ttm_resource_intersects(struct ttm_device *bdev,
271 struct ttm_resource *res,
272 const struct ttm_place *place,
275 struct ttm_resource_manager *man;
280 man = ttm_manager_type(bdev, res->mem_type);
281 if (!place || !man->func->intersects)
284 return man->func->intersects(man, res, place, size);
288 * ttm_resource_compatible - test for compatibility
290 * @bdev: TTM device structure
291 * @res: The resource to test
292 * @place: The placement to test
293 * @size: How many bytes the new allocation needs.
295 * Test if @res compatible with @place and @size.
297 * Returns true if the res placement compatible with @place and @size.
299 bool ttm_resource_compatible(struct ttm_device *bdev,
300 struct ttm_resource *res,
301 const struct ttm_place *place,
304 struct ttm_resource_manager *man;
309 man = ttm_manager_type(bdev, res->mem_type);
310 if (!man->func->compatible)
313 return man->func->compatible(man, res, place, size);
316 static bool ttm_resource_places_compat(struct ttm_resource *res,
317 const struct ttm_place *places,
318 unsigned num_placement)
320 struct ttm_buffer_object *bo = res->bo;
321 struct ttm_device *bdev = bo->bdev;
324 if (res->placement & TTM_PL_FLAG_TEMPORARY)
327 for (i = 0; i < num_placement; i++) {
328 const struct ttm_place *heap = &places[i];
330 if (!ttm_resource_compatible(bdev, res, heap, bo->base.size))
333 if ((res->mem_type == heap->mem_type) &&
334 (!(heap->flags & TTM_PL_FLAG_CONTIGUOUS) ||
335 (res->placement & TTM_PL_FLAG_CONTIGUOUS)))
342 * ttm_resource_compat - check if resource is compatible with placement
344 * @res: the resource to check
345 * @placement: the placement to check against
347 * Returns true if the placement is compatible.
349 bool ttm_resource_compat(struct ttm_resource *res,
350 struct ttm_placement *placement)
352 if (ttm_resource_places_compat(res, placement->placement,
353 placement->num_placement))
356 if ((placement->busy_placement != placement->placement ||
357 placement->num_busy_placement > placement->num_placement) &&
358 ttm_resource_places_compat(res, placement->busy_placement,
359 placement->num_busy_placement))
364 EXPORT_SYMBOL(ttm_resource_compat);
366 void ttm_resource_set_bo(struct ttm_resource *res,
367 struct ttm_buffer_object *bo)
369 spin_lock(&bo->bdev->lru_lock);
371 spin_unlock(&bo->bdev->lru_lock);
375 * ttm_resource_manager_init
377 * @man: memory manager object to init
378 * @bdev: ttm device this manager belongs to
379 * @size: size of managed resources in arbitrary units
381 * Initialise core parts of a manager object.
383 void ttm_resource_manager_init(struct ttm_resource_manager *man,
384 struct ttm_device *bdev,
389 spin_lock_init(&man->move_lock);
394 for (i = 0; i < TTM_MAX_BO_PRIORITY; ++i)
395 INIT_LIST_HEAD(&man->lru[i]);
398 EXPORT_SYMBOL(ttm_resource_manager_init);
401 * ttm_resource_manager_evict_all
403 * @bdev - device to use
404 * @man - manager to use
406 * Evict all the objects out of a memory manager until it is empty.
407 * Part of memory manager cleanup sequence.
409 int ttm_resource_manager_evict_all(struct ttm_device *bdev,
410 struct ttm_resource_manager *man)
412 struct ttm_operation_ctx ctx = {
413 .interruptible = false,
414 .no_wait_gpu = false,
417 struct dma_fence *fence;
422 * Can't use standard list traversal since we're unlocking.
425 spin_lock(&bdev->lru_lock);
426 for (i = 0; i < TTM_MAX_BO_PRIORITY; ++i) {
427 while (!list_empty(&man->lru[i])) {
428 spin_unlock(&bdev->lru_lock);
429 ret = ttm_mem_evict_first(bdev, man, NULL, &ctx,
433 spin_lock(&bdev->lru_lock);
436 spin_unlock(&bdev->lru_lock);
438 spin_lock(&man->move_lock);
439 fence = dma_fence_get(man->move);
440 spin_unlock(&man->move_lock);
443 ret = dma_fence_wait(fence, false);
444 dma_fence_put(fence);
451 EXPORT_SYMBOL(ttm_resource_manager_evict_all);
454 * ttm_resource_manager_usage
456 * @man: A memory manager object.
458 * Return how many resources are currently used.
460 uint64_t ttm_resource_manager_usage(struct ttm_resource_manager *man)
464 spin_lock(&man->bdev->lru_lock);
466 spin_unlock(&man->bdev->lru_lock);
469 EXPORT_SYMBOL(ttm_resource_manager_usage);
472 * ttm_resource_manager_debug
474 * @man: manager type to dump.
475 * @p: printer to use for debug.
477 void ttm_resource_manager_debug(struct ttm_resource_manager *man,
478 struct drm_printer *p)
480 drm_printf(p, " use_type: %d\n", man->use_type);
481 drm_printf(p, " use_tt: %d\n", man->use_tt);
482 drm_printf(p, " size: %llu\n", man->size);
483 drm_printf(p, " usage: %llu\n", ttm_resource_manager_usage(man));
484 if (man->func->debug)
485 man->func->debug(man, p);
487 EXPORT_SYMBOL(ttm_resource_manager_debug);
490 * ttm_resource_manager_first
492 * @man: resource manager to iterate over
493 * @cursor: cursor to record the position
495 * Returns the first resource from the resource manager.
497 struct ttm_resource *
498 ttm_resource_manager_first(struct ttm_resource_manager *man,
499 struct ttm_resource_cursor *cursor)
501 struct ttm_resource *res;
503 lockdep_assert_held(&man->bdev->lru_lock);
505 for (cursor->priority = 0; cursor->priority < TTM_MAX_BO_PRIORITY;
507 list_for_each_entry(res, &man->lru[cursor->priority], lru)
514 * ttm_resource_manager_next
516 * @man: resource manager to iterate over
517 * @cursor: cursor to record the position
518 * @res: the current resource pointer
520 * Returns the next resource from the resource manager.
522 struct ttm_resource *
523 ttm_resource_manager_next(struct ttm_resource_manager *man,
524 struct ttm_resource_cursor *cursor,
525 struct ttm_resource *res)
527 lockdep_assert_held(&man->bdev->lru_lock);
529 list_for_each_entry_continue(res, &man->lru[cursor->priority], lru)
532 for (++cursor->priority; cursor->priority < TTM_MAX_BO_PRIORITY;
534 list_for_each_entry(res, &man->lru[cursor->priority], lru)
540 static void ttm_kmap_iter_iomap_map_local(struct ttm_kmap_iter *iter,
541 struct iosys_map *dmap,
544 struct ttm_kmap_iter_iomap *iter_io =
545 container_of(iter, typeof(*iter_io), base);
549 while (i >= iter_io->cache.end) {
550 iter_io->cache.sg = iter_io->cache.sg ?
551 sg_next(iter_io->cache.sg) : iter_io->st->sgl;
552 iter_io->cache.i = iter_io->cache.end;
553 iter_io->cache.end += sg_dma_len(iter_io->cache.sg) >>
555 iter_io->cache.offs = sg_dma_address(iter_io->cache.sg) -
559 if (i < iter_io->cache.i) {
560 iter_io->cache.end = 0;
561 iter_io->cache.sg = NULL;
565 addr = io_mapping_map_local_wc(iter_io->iomap, iter_io->cache.offs +
566 (((resource_size_t)i - iter_io->cache.i)
568 iosys_map_set_vaddr_iomem(dmap, addr);
571 static void ttm_kmap_iter_iomap_unmap_local(struct ttm_kmap_iter *iter,
572 struct iosys_map *map)
574 io_mapping_unmap_local(map->vaddr_iomem);
577 static const struct ttm_kmap_iter_ops ttm_kmap_iter_io_ops = {
578 .map_local = ttm_kmap_iter_iomap_map_local,
579 .unmap_local = ttm_kmap_iter_iomap_unmap_local,
584 * ttm_kmap_iter_iomap_init - Initialize a struct ttm_kmap_iter_iomap
585 * @iter_io: The struct ttm_kmap_iter_iomap to initialize.
586 * @iomap: The struct io_mapping representing the underlying linear io_memory.
587 * @st: sg_table into @iomap, representing the memory of the struct
589 * @start: Offset that needs to be subtracted from @st to make
590 * sg_dma_address(st->sgl) - @start == 0 for @iomap start.
592 * Return: Pointer to the embedded struct ttm_kmap_iter.
594 struct ttm_kmap_iter *
595 ttm_kmap_iter_iomap_init(struct ttm_kmap_iter_iomap *iter_io,
596 struct io_mapping *iomap,
598 resource_size_t start)
600 iter_io->base.ops = &ttm_kmap_iter_io_ops;
601 iter_io->iomap = iomap;
603 iter_io->start = start;
604 memset(&iter_io->cache, 0, sizeof(iter_io->cache));
606 return &iter_io->base;
608 EXPORT_SYMBOL(ttm_kmap_iter_iomap_init);
611 * DOC: Linear io iterator
613 * This code should die in the not too near future. Best would be if we could
614 * make io-mapping use memremap for all io memory, and have memremap
615 * implement a kmap_local functionality. We could then strip a huge amount of
616 * code. These linear io iterators are implemented to mimic old functionality,
617 * and they don't use kmap_local semantics at all internally. Rather ioremap or
618 * friends, and at least on 32-bit they add global TLB flushes and points
622 static void ttm_kmap_iter_linear_io_map_local(struct ttm_kmap_iter *iter,
623 struct iosys_map *dmap,
626 struct ttm_kmap_iter_linear_io *iter_io =
627 container_of(iter, typeof(*iter_io), base);
629 *dmap = iter_io->dmap;
630 iosys_map_incr(dmap, i * PAGE_SIZE);
633 static const struct ttm_kmap_iter_ops ttm_kmap_iter_linear_io_ops = {
634 .map_local = ttm_kmap_iter_linear_io_map_local,
639 * ttm_kmap_iter_linear_io_init - Initialize an iterator for linear io memory
640 * @iter_io: The iterator to initialize
641 * @bdev: The TTM device
642 * @mem: The ttm resource representing the iomap.
644 * This function is for internal TTM use only. It sets up a memcpy kmap iterator
645 * pointing at a linear chunk of io memory.
647 * Return: A pointer to the embedded struct ttm_kmap_iter or error pointer on
650 struct ttm_kmap_iter *
651 ttm_kmap_iter_linear_io_init(struct ttm_kmap_iter_linear_io *iter_io,
652 struct ttm_device *bdev,
653 struct ttm_resource *mem)
657 ret = ttm_mem_io_reserve(bdev, mem);
660 if (!mem->bus.is_iomem) {
666 iosys_map_set_vaddr(&iter_io->dmap, mem->bus.addr);
667 iter_io->needs_unmap = false;
669 iter_io->needs_unmap = true;
670 memset(&iter_io->dmap, 0, sizeof(iter_io->dmap));
671 if (mem->bus.caching == ttm_write_combined)
672 iosys_map_set_vaddr_iomem(&iter_io->dmap,
673 ioremap_wc(mem->bus.offset,
675 else if (mem->bus.caching == ttm_cached)
676 iosys_map_set_vaddr(&iter_io->dmap,
677 memremap(mem->bus.offset, mem->size,
682 /* If uncached requested or if mapping cached or wc failed */
683 if (iosys_map_is_null(&iter_io->dmap))
684 iosys_map_set_vaddr_iomem(&iter_io->dmap,
685 ioremap(mem->bus.offset,
688 if (iosys_map_is_null(&iter_io->dmap)) {
694 iter_io->base.ops = &ttm_kmap_iter_linear_io_ops;
695 return &iter_io->base;
698 ttm_mem_io_free(bdev, mem);
704 * ttm_kmap_iter_linear_io_fini - Clean up an iterator for linear io memory
705 * @iter_io: The iterator to initialize
706 * @bdev: The TTM device
707 * @mem: The ttm resource representing the iomap.
709 * This function is for internal TTM use only. It cleans up a memcpy kmap
710 * iterator initialized by ttm_kmap_iter_linear_io_init.
713 ttm_kmap_iter_linear_io_fini(struct ttm_kmap_iter_linear_io *iter_io,
714 struct ttm_device *bdev,
715 struct ttm_resource *mem)
717 if (iter_io->needs_unmap && iosys_map_is_set(&iter_io->dmap)) {
718 if (iter_io->dmap.is_iomem)
719 iounmap(iter_io->dmap.vaddr_iomem);
721 memunmap(iter_io->dmap.vaddr);
724 ttm_mem_io_free(bdev, mem);
727 #if defined(CONFIG_DEBUG_FS)
729 static int ttm_resource_manager_show(struct seq_file *m, void *unused)
731 struct ttm_resource_manager *man =
732 (struct ttm_resource_manager *)m->private;
733 struct drm_printer p = drm_seq_file_printer(m);
734 ttm_resource_manager_debug(man, &p);
737 DEFINE_SHOW_ATTRIBUTE(ttm_resource_manager);
742 * ttm_resource_manager_create_debugfs - Create debugfs entry for specified
744 * @man: The TTM resource manager for which the debugfs stats file be creates
745 * @parent: debugfs directory in which the file will reside
746 * @name: The filename to create.
748 * This function setups up a debugfs file that can be used to look
749 * at debug statistics of the specified ttm_resource_manager.
751 void ttm_resource_manager_create_debugfs(struct ttm_resource_manager *man,
752 struct dentry * parent,
755 #if defined(CONFIG_DEBUG_FS)
756 debugfs_create_file(name, 0444, parent, man, &ttm_resource_manager_fops);
759 EXPORT_SYMBOL(ttm_resource_manager_create_debugfs);