linux/drivers/gpu/drm/nouveau/dispnv50/crc.c

// SPDX-License-Identifier: MIT
#include <linux/debugfs.h>
#include <linux/string.h>

#include <drm/drm_crtc.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_vblank.h>
#include <drm/drm_vblank_work.h>

#include <nvif/class.h>
#include <nvif/cl0002.h>
#include <nvif/timer.h>

#include <nvhw/class/cl907d.h>

#include "nouveau_drv.h"
#include "core.h"
#include "head.h"
#include "wndw.h"
#include "handles.h"
#include "crc.h"

static const char * const nv50_crc_sources[] = …;

static int nv50_crc_parse_source(const char *buf, enum nv50_crc_source *s)
{ … }

int
nv50_crc_verify_source(struct drm_crtc *crtc, const char *source_name,
		       size_t *values_cnt)
{ … }

const char *const *nv50_crc_get_sources(struct drm_crtc *crtc, size_t *count)
{ … }

static void
nv50_crc_program_ctx(struct nv50_head *head,
		     struct nv50_crc_notifier_ctx *ctx)
{ … }

static void nv50_crc_ctx_flip_work(struct kthread_work *base)
{ … }

static inline void nv50_crc_reset_ctx(struct nv50_crc_notifier_ctx *ctx)
{ … }

static void
nv50_crc_get_entries(struct nv50_head *head,
		     const struct nv50_crc_func *func,
		     enum nv50_crc_source source)
{ … }

void nv50_crc_handle_vblank(struct nv50_head *head)
{ … }

static void nv50_crc_wait_ctx_finished(struct nv50_head *head,
				       const struct nv50_crc_func *func,
				       struct nv50_crc_notifier_ctx *ctx)
{ … }

void nv50_crc_atomic_stop_reporting(struct drm_atomic_state *state)
{ … }

void nv50_crc_atomic_init_notifier_contexts(struct drm_atomic_state *state)
{ … }

void nv50_crc_atomic_release_notifier_contexts(struct drm_atomic_state *state)
{ … }

void nv50_crc_atomic_start_reporting(struct drm_atomic_state *state)
{ … }

int nv50_crc_atomic_check_head(struct nv50_head *head,
			       struct nv50_head_atom *asyh,
			       struct nv50_head_atom *armh)
{ … }

void nv50_crc_atomic_check_outp(struct nv50_atom *atom)
{ … }

static enum nv50_crc_source_type
nv50_crc_source_type(struct nouveau_encoder *outp,
		     enum nv50_crc_source source)
{ … }

void nv50_crc_atomic_set(struct nv50_head *head,
			 struct nv50_head_atom *asyh)
{ … }

void nv50_crc_atomic_clr(struct nv50_head *head)
{ … }

static inline int
nv50_crc_raster_type(enum nv50_crc_source source)
{ … }

/* We handle mapping the memory for CRC notifiers ourselves, since each
 * notifier needs it's own handle
 */
static inline int
nv50_crc_ctx_init(struct nv50_head *head, struct nvif_mmu *mmu,
		  struct nv50_crc_notifier_ctx *ctx, size_t len, int idx)
{ … }

static inline void
nv50_crc_ctx_fini(struct nv50_crc_notifier_ctx *ctx)
{ … }

int nv50_crc_set_source(struct drm_crtc *crtc, const char *source_str)
{ … }

static int
nv50_crc_debugfs_flip_threshold_get(struct seq_file *m, void *data)
{ … }

static int
nv50_crc_debugfs_flip_threshold_open(struct inode *inode, struct file *file)
{ … }

static ssize_t
nv50_crc_debugfs_flip_threshold_set(struct file *file,
				    const char __user *ubuf, size_t len,
				    loff_t *offp)
{ … }

static const struct file_operations nv50_crc_flip_threshold_fops = …;

int nv50_head_crc_late_register(struct nv50_head *head)
{ … }

static inline void
nv50_crc_init_head(struct nv50_disp *disp, const struct nv50_crc_func *func,
		   struct nv50_head *head)
{ … }

void nv50_crc_init(struct drm_device *dev)
{ … }