linux/drivers/gpu/drm/xe/xe_hw_fence.c

// SPDX-License-Identifier: MIT
/*
 * Copyright © 2021 Intel Corporation
 */

#include "xe_hw_fence.h"

#include <linux/device.h>
#include <linux/slab.h>

#include "xe_bo.h"
#include "xe_device.h"
#include "xe_gt.h"
#include "xe_hw_engine.h"
#include "xe_macros.h"
#include "xe_map.h"
#include "xe_trace.h"

static struct kmem_cache *xe_hw_fence_slab;

int __init xe_hw_fence_module_init(void)
{ … }

void xe_hw_fence_module_exit(void)
{ … }

static struct xe_hw_fence *fence_alloc(void)
{ … }

static void fence_free(struct rcu_head *rcu)
{ … }

static void hw_fence_irq_run_cb(struct irq_work *work)
{ … }

void xe_hw_fence_irq_init(struct xe_hw_fence_irq *irq)
{ … }

void xe_hw_fence_irq_finish(struct xe_hw_fence_irq *irq)
{ … }

void xe_hw_fence_irq_run(struct xe_hw_fence_irq *irq)
{ … }

void xe_hw_fence_irq_stop(struct xe_hw_fence_irq *irq)
{ … }

void xe_hw_fence_irq_start(struct xe_hw_fence_irq *irq)
{ … }

void xe_hw_fence_ctx_init(struct xe_hw_fence_ctx *ctx, struct xe_gt *gt,
			  struct xe_hw_fence_irq *irq, const char *name)
{ … }

void xe_hw_fence_ctx_finish(struct xe_hw_fence_ctx *ctx)
{ … }

static struct xe_hw_fence *to_xe_hw_fence(struct dma_fence *fence);

static struct xe_hw_fence_irq *xe_hw_fence_irq(struct xe_hw_fence *fence)
{ … }

static const char *xe_hw_fence_get_driver_name(struct dma_fence *dma_fence)
{ … }

static const char *xe_hw_fence_get_timeline_name(struct dma_fence *dma_fence)
{ … }

static bool xe_hw_fence_signaled(struct dma_fence *dma_fence)
{ … }

static bool xe_hw_fence_enable_signaling(struct dma_fence *dma_fence)
{ … }

static void xe_hw_fence_release(struct dma_fence *dma_fence)
{ … }

static const struct dma_fence_ops xe_hw_fence_ops = …;

static struct xe_hw_fence *to_xe_hw_fence(struct dma_fence *fence)
{ … }

/**
 * xe_hw_fence_alloc() -  Allocate an hw fence.
 *
 * Allocate but don't initialize an hw fence.
 *
 * Return: Pointer to the allocated fence or
 * negative error pointer on error.
 */
struct dma_fence *xe_hw_fence_alloc(void)
{ … }

/**
 * xe_hw_fence_free() - Free an hw fence.
 * @fence: Pointer to the fence to free.
 *
 * Frees an hw fence that hasn't yet been
 * initialized.
 */
void xe_hw_fence_free(struct dma_fence *fence)
{ … }

/**
 * xe_hw_fence_init() - Initialize an hw fence.
 * @fence: Pointer to the fence to initialize.
 * @ctx: Pointer to the struct xe_hw_fence_ctx fence context.
 * @seqno_map: Pointer to the map into where the seqno is blitted.
 *
 * Initializes a pre-allocated hw fence.
 * After initialization, the fence is subject to normal
 * dma-fence refcounting.
 */
void xe_hw_fence_init(struct dma_fence *fence, struct xe_hw_fence_ctx *ctx,
		      struct iosys_map seqno_map)
{ … }