Contributors: 6
Author Tokens Token Proportion Commits Commit Proportion
Matthew Brost 799 66.47% 1 12.50%
Thomas Hellstrom 305 25.37% 2 25.00%
Maarten Lankhorst 79 6.57% 1 12.50%
Francois Dugast 10 0.83% 2 25.00%
Brian Welty 7 0.58% 1 12.50%
Lucas De Marchi 2 0.17% 1 12.50%
Total 1202 8 


/* SPDX-License-Identifier: GPL-2.0-only OR MIT */
/*
 * Copyright 2020 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef _XE_RES_CURSOR_H_
#define _XE_RES_CURSOR_H_

#include <linux/scatterlist.h>

#include <drm/drm_pagemap.h>
#include <drm/ttm/ttm_placement.h>
#include <drm/ttm/ttm_range_manager.h>
#include <drm/ttm/ttm_resource.h>
#include <drm/ttm/ttm_tt.h>

#include "xe_bo.h"
#include "xe_device.h"
#include "xe_macros.h"
#include "xe_svm.h"
#include "xe_ttm_vram_mgr.h"

/**
 * struct xe_res_cursor - state for walking over dma mapping, vram_mgr,
 * stolen_mgr, and gtt_mgr allocations
 */
struct xe_res_cursor {
	/** @start: Start of cursor */
	u64 start;
	/** @size: Size of the current segment. */
	u64 size;
	/** @remaining: Remaining bytes in cursor */
	u64 remaining;
	/** @node: Opaque point current node cursor */
	void *node;
	/** @mem_type: Memory type */
	u32 mem_type;
	/** @sgl: Scatterlist for cursor */
	struct scatterlist *sgl;
	/** @dma_addr: Current element in a struct drm_pagemap_device_addr array */
	const struct drm_pagemap_device_addr *dma_addr;
	/** @mm: Buddy allocator for VRAM cursor */
	struct drm_buddy *mm;
	/**
	 * @dma_start: DMA start address for the current segment.
	 * This may be different to @dma_addr.addr since elements in
	 * the array may be coalesced to a single segment.
	 */
	u64 dma_start;
	/** @dma_seg_size: Size of the current DMA segment. */
	u64 dma_seg_size;
};

static struct drm_buddy *xe_res_get_buddy(struct ttm_resource *res)
{
	struct ttm_resource_manager *mgr;

	mgr = ttm_manager_type(res->bo->bdev, res->mem_type);
	return &to_xe_ttm_vram_mgr(mgr)->mm;
}

/**
 * xe_res_first - initialize a xe_res_cursor
 *
 * @res: TTM resource object to walk
 * @start: Start of the range
 * @size: Size of the range
 * @cur: cursor object to initialize
 *
 * Start walking over the range of allocations between @start and @size.
 */
static inline void xe_res_first(struct ttm_resource *res,
				u64 start, u64 size,
				struct xe_res_cursor *cur)
{
	cur->sgl = NULL;
	cur->dma_addr = NULL;
	if (!res)
		goto fallback;

	XE_WARN_ON(start + size > res->size);

	cur->mem_type = res->mem_type;

	switch (cur->mem_type) {
	case XE_PL_STOLEN:
	case XE_PL_VRAM0:
	case XE_PL_VRAM1: {
		struct drm_buddy_block *block;
		struct list_head *head, *next;
		struct drm_buddy *mm = xe_res_get_buddy(res);

		head = &to_xe_ttm_vram_mgr_resource(res)->blocks;

		block = list_first_entry_or_null(head,
						 struct drm_buddy_block,
						 link);
		if (!block)
			goto fallback;

		while (start >= drm_buddy_block_size(mm, block)) {
			start -= drm_buddy_block_size(mm, block);

			next = block->link.next;
			if (next != head)
				block = list_entry(next, struct drm_buddy_block,
						   link);
		}

		cur->mm = mm;
		cur->start = drm_buddy_block_offset(block) + start;
		cur->size = min(drm_buddy_block_size(mm, block) - start,
				size);
		cur->remaining = size;
		cur->node = block;
		break;
	}
	default:
		goto fallback;
	}

	return;

fallback:
	cur->start = start;
	cur->size = size;
	cur->remaining = size;
	cur->node = NULL;
	cur->mem_type = XE_PL_TT;
	XE_WARN_ON(res && start + size > res->size);
}

static inline void __xe_res_sg_next(struct xe_res_cursor *cur)
{
	struct scatterlist *sgl = cur->sgl;
	u64 start = cur->start;

	while (start >= sg_dma_len(sgl)) {
		start -= sg_dma_len(sgl);
		sgl = sg_next(sgl);
		XE_WARN_ON(!sgl);
	}

	cur->start = start;
	cur->size = sg_dma_len(sgl) - start;
	cur->sgl = sgl;
}

/**
 * __xe_res_dma_next() - Advance the cursor when end-of-segment is reached
 * @cur: The cursor
 */
static inline void __xe_res_dma_next(struct xe_res_cursor *cur)
{
	const struct drm_pagemap_device_addr *addr = cur->dma_addr;
	u64 start = cur->start;

	while (start >= cur->dma_seg_size) {
		start -= cur->dma_seg_size;
		addr++;
		cur->dma_seg_size = PAGE_SIZE << addr->order;
	}
	cur->dma_start = addr->addr;

	/* Coalesce array_elements */
	while (cur->dma_seg_size - start < cur->remaining) {
		if (cur->dma_start + cur->dma_seg_size != addr[1].addr ||
		    addr->proto != addr[1].proto)
			break;
		addr++;
		cur->dma_seg_size += PAGE_SIZE << addr->order;
	}

	cur->dma_addr = addr;
	cur->start = start;
	cur->size = cur->dma_seg_size - start;
}

/**
 * xe_res_first_sg - initialize a xe_res_cursor with a scatter gather table
 *
 * @sg: scatter gather table to walk
 * @start: Start of the range
 * @size: Size of the range
 * @cur: cursor object to initialize
 *
 * Start walking over the range of allocations between @start and @size.
 */
static inline void xe_res_first_sg(const struct sg_table *sg,
				   u64 start, u64 size,
				   struct xe_res_cursor *cur)
{
	XE_WARN_ON(!sg);
	cur->node = NULL;
	cur->start = start;
	cur->remaining = size;
	cur->size = 0;
	cur->dma_addr = NULL;
	cur->sgl = sg->sgl;
	cur->mem_type = XE_PL_TT;
	__xe_res_sg_next(cur);
}

/**
 * xe_res_first_dma - initialize a xe_res_cursor with dma_addr array
 *
 * @dma_addr: struct drm_pagemap_device_addr array to walk
 * @start: Start of the range
 * @size: Size of the range
 * @cur: cursor object to initialize
 *
 * Start walking over the range of allocations between @start and @size.
 */
static inline void xe_res_first_dma(const struct drm_pagemap_device_addr *dma_addr,
				    u64 start, u64 size,
				    struct xe_res_cursor *cur)
{
	XE_WARN_ON(!dma_addr);
	XE_WARN_ON(!IS_ALIGNED(start, PAGE_SIZE) ||
		   !IS_ALIGNED(size, PAGE_SIZE));

	cur->node = NULL;
	cur->start = start;
	cur->remaining = size;
	cur->dma_seg_size = PAGE_SIZE << dma_addr->order;
	cur->dma_start = 0;
	cur->size = 0;
	cur->dma_addr = dma_addr;
	__xe_res_dma_next(cur);
	cur->sgl = NULL;
	cur->mem_type = XE_PL_TT;
}

/**
 * xe_res_next - advance the cursor
 *
 * @cur: the cursor to advance
 * @size: number of bytes to move forward
 *
 * Move the cursor @size bytes forwrad, walking to the next node if necessary.
 */
static inline void xe_res_next(struct xe_res_cursor *cur, u64 size)
{
	struct drm_buddy_block *block;
	struct list_head *next;
	u64 start;

	XE_WARN_ON(size > cur->remaining);

	cur->remaining -= size;
	if (!cur->remaining)
		return;

	if (cur->size > size) {
		cur->size -= size;
		cur->start += size;
		return;
	}

	if (cur->dma_addr) {
		cur->start += size;
		__xe_res_dma_next(cur);
		return;
	}

	if (cur->sgl) {
		cur->start += size;
		__xe_res_sg_next(cur);
		return;
	}

	switch (cur->mem_type) {
	case XE_PL_STOLEN:
	case XE_PL_VRAM0:
	case XE_PL_VRAM1:
		start = size - cur->size;
		block = cur->node;

		next = block->link.next;
		block = list_entry(next, struct drm_buddy_block, link);


		while (start >= drm_buddy_block_size(cur->mm, block)) {
			start -= drm_buddy_block_size(cur->mm, block);

			next = block->link.next;
			block = list_entry(next, struct drm_buddy_block, link);
		}

		cur->start = drm_buddy_block_offset(block) + start;
		cur->size = min(drm_buddy_block_size(cur->mm, block) - start,
				cur->remaining);
		cur->node = block;
		break;
	default:
		return;
	}
}

/**
 * xe_res_dma - return dma address of cursor at current position
 *
 * @cur: the cursor to return the dma address from
 */
static inline u64 xe_res_dma(const struct xe_res_cursor *cur)
{
	if (cur->dma_addr)
		return cur->dma_start + cur->start;
	else if (cur->sgl)
		return sg_dma_address(cur->sgl) + cur->start;
	else
		return cur->start;
}

/**
 * xe_res_is_vram() - Whether the cursor current dma address points to
 * same-device VRAM
 * @cur: The cursor.
 *
 * Return: true iff the address returned by xe_res_dma() points to internal vram.
 */
static inline bool xe_res_is_vram(const struct xe_res_cursor *cur)
{
	if (cur->dma_addr)
		return cur->dma_addr->proto == XE_INTERCONNECT_VRAM;

	switch (cur->mem_type) {
	case XE_PL_STOLEN:
	case XE_PL_VRAM0:
	case XE_PL_VRAM1:
		return true;
	default:
		break;
	}

	return false;
}
#endif