drivers/gpu/drm/verisilicon/vs_cursor_plane.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2026 Institute of Software, Chinese Academy of Sciences (ISCAS)
 *
 * Authors:
 * Icenowy Zheng <zhengxingda@iscas.ac.cn>
 */

#include <linux/log2.h>
#include <linux/regmap.h>

#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_crtc.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_gem_atomic_helper.h>
#include <drm/drm_modeset_helper_vtables.h>
#include <drm/drm_plane.h>
#include <drm/drm_print.h>

#include "vs_crtc.h"
#include "vs_plane.h"
#include "vs_dc.h"
#include "vs_hwdb.h"
#include "vs_cursor_plane_regs.h"

#define VSDC_MIN_CURSOR_SIZE 32
#define VSDC_MAX_CURSOR_SIZE 256

#define VSDC_CURSOR_LOCATION_MAX_POSITIVE BIT_MASK(15)
#define VSDC_CURSOR_LOCATION_MAX_NEGATIVE BIT_MASK(5)

static bool vs_cursor_plane_check_coord(int32_t coord)
{
	if (coord >= 0)
		return coord <= VSDC_CURSOR_LOCATION_MAX_POSITIVE;
	else
		return (-coord) <= VSDC_CURSOR_LOCATION_MAX_NEGATIVE;
}

static int vs_cursor_plane_atomic_check(struct drm_plane *plane,
					struct drm_atomic_commit *state)
{
	struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
										 plane);
	struct drm_crtc *crtc = new_plane_state->crtc;
	struct drm_framebuffer *fb = new_plane_state->fb;
	struct drm_crtc_state *crtc_state = NULL;
	struct vs_crtc *vcrtc;
	struct vs_dc *dc;
	int ret;

	if (crtc)
		crtc_state = drm_atomic_get_new_crtc_state(state, crtc);

	ret = drm_atomic_helper_check_plane_state(new_plane_state,
						  crtc_state,
						  DRM_PLANE_NO_SCALING,
						  DRM_PLANE_NO_SCALING,
						  true, true);
	if (ret)
		return ret;

	if (!new_plane_state->visible)
		return 0; /* Skip validity check */

	vcrtc = drm_crtc_to_vs_crtc(crtc);
	dc = vcrtc->dc;

	/* Only certain PoT square sizes is supported. */
	if (!is_power_of_2(new_plane_state->crtc_w) ||
	    new_plane_state->crtc_w < VSDC_MIN_CURSOR_SIZE ||
	    new_plane_state->crtc_w > dc->identity.max_cursor_size)
		return -EINVAL;

	if (new_plane_state->crtc_w != new_plane_state->crtc_h)
		return -EINVAL;

	/* Check if the cursor is inside the register fields' range */
	if (!vs_cursor_plane_check_coord(new_plane_state->crtc_x) ||
	    !vs_cursor_plane_check_coord(new_plane_state->crtc_y))
		return -EINVAL;

	/* Extra line padding isn't supported */
	if (fb->pitches[0] !=
	    drm_format_info_min_pitch(fb->format, 0, new_plane_state->crtc_w))
		return -EINVAL;

	return 0;
}

static void vs_cursor_plane_commit(struct vs_dc *dc, unsigned int output)
{
	regmap_set_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
			VSDC_CURSOR_CONFIG_COMMIT |
			VSDC_CURSOR_CONFIG_IMG_UPDATE);
}

static void vs_cursor_plane_atomic_enable(struct drm_plane *plane,
					   struct drm_atomic_commit *atomic_state)
{
	struct drm_plane_state *state = drm_atomic_get_new_plane_state(atomic_state,
								       plane);
	struct drm_crtc *crtc = state->crtc;
	struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
	unsigned int output = vcrtc->id;
	struct vs_dc *dc = vcrtc->dc;

	regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
			   VSDC_CURSOR_CONFIG_FMT_MASK,
			   VSDC_CURSOR_CONFIG_FMT_ARGB8888);

	vs_cursor_plane_commit(dc, output);
}

static void vs_cursor_plane_atomic_disable(struct drm_plane *plane,
					    struct drm_atomic_commit *atomic_state)
{
	struct drm_plane_state *state = drm_atomic_get_old_plane_state(atomic_state,
								       plane);
	struct drm_crtc *crtc = state->crtc;
	struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
	unsigned int output = vcrtc->id;
	struct vs_dc *dc = vcrtc->dc;

	regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
			   VSDC_CURSOR_CONFIG_FMT_MASK,
			   VSDC_CURSOR_CONFIG_FMT_OFF);

	vs_cursor_plane_commit(dc, output);
}

static void vs_cursor_plane_atomic_update(struct drm_plane *plane,
					   struct drm_atomic_commit *atomic_state)
{
	struct drm_plane_state *state = drm_atomic_get_new_plane_state(atomic_state,
								       plane);
	struct drm_framebuffer *fb = state->fb;
	struct drm_crtc *crtc = state->crtc;
	struct vs_dc *dc;
	struct vs_crtc *vcrtc;
	unsigned int output;
	dma_addr_t dma_addr;

	if (!state->visible) {
		vs_cursor_plane_atomic_disable(plane, atomic_state);
		return;
	}

	vcrtc = drm_crtc_to_vs_crtc(crtc);
	output = vcrtc->id;
	dc = vcrtc->dc;

	/* Other sizes should be rejected by atomic_check */
	switch (state->crtc_w) {
	case 32:
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_SIZE_MASK,
				   VSDC_CURSOR_CONFIG_SIZE_32);
		break;
	case 64:
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_SIZE_MASK,
				   VSDC_CURSOR_CONFIG_SIZE_64);
		break;
	case 128:
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_SIZE_MASK,
				   VSDC_CURSOR_CONFIG_SIZE_128);
		break;
	case 256:
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_SIZE_MASK,
				   VSDC_CURSOR_CONFIG_SIZE_256);
		break;
	}

	dma_addr = vs_fb_get_dma_addr(fb, &state->src);

	regmap_write(dc->regs, VSDC_CURSOR_ADDRESS(output),
		     lower_32_bits(dma_addr));

	/*
	 * The X_OFF and Y_OFF fields define which point does the LOCATION
	 * register represent in the cursor image, and LOCATION register
	 * values are unsigned. To for positive left-top  coordinates the
	 * offset is set to 0 and the location is set to the coordinate, for
	 * negative coordinates the location is set to 0 and the offset
	 * is set to the opposite number of the coordinate to offset the
	 * cursor image partly off-screen.
	 */
	if (state->crtc_x >= 0) {
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_X_OFF_MASK, 0);
		regmap_update_bits(dc->regs, VSDC_CURSOR_LOCATION(output),
				   VSDC_CURSOR_LOCATION_X_MASK,
				   VSDC_CURSOR_LOCATION_X(state->crtc_x));
	} else {
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_X_OFF_MASK,
				   -state->crtc_x);
		regmap_update_bits(dc->regs, VSDC_CURSOR_LOCATION(output),
				   VSDC_CURSOR_LOCATION_X_MASK, 0);
	}

	if (state->crtc_y >= 0) {
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_Y_OFF_MASK, 0);
		regmap_update_bits(dc->regs, VSDC_CURSOR_LOCATION(output),
				   VSDC_CURSOR_LOCATION_Y_MASK,
				   VSDC_CURSOR_LOCATION_Y(state->crtc_y));
	} else {
		regmap_update_bits(dc->regs, VSDC_CURSOR_CONFIG(output),
				   VSDC_CURSOR_CONFIG_Y_OFF_MASK,
				   -state->crtc_y);
		regmap_update_bits(dc->regs, VSDC_CURSOR_LOCATION(output),
				   VSDC_CURSOR_LOCATION_Y_MASK, 0);
	}

	vs_cursor_plane_commit(dc, output);
}

static const struct drm_plane_helper_funcs vs_cursor_plane_helper_funcs = {
	.atomic_check	= vs_cursor_plane_atomic_check,
	.atomic_update	= vs_cursor_plane_atomic_update,
	.atomic_enable	= vs_cursor_plane_atomic_enable,
	.atomic_disable	= vs_cursor_plane_atomic_disable,
};

static const struct drm_plane_funcs vs_cursor_plane_funcs = {
	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
	.disable_plane		= drm_atomic_helper_disable_plane,
	.reset			= drm_atomic_helper_plane_reset,
	.update_plane		= drm_atomic_helper_update_plane,
};

static const u32 vs_cursor_plane_formats[] = {
	DRM_FORMAT_ARGB8888,
};

static const u64 vs_cursor_plane_modifiers[] = {
	DRM_FORMAT_MOD_LINEAR,
	DRM_FORMAT_MOD_INVALID, /* sentinel */
};

struct drm_plane *vs_cursor_plane_init(struct drm_device *drm_dev,
				       struct vs_dc *dc)
{
	int32_t max_cursor_size = dc->identity.max_cursor_size;
	struct drm_plane *plane;

	if (drm_WARN_ON_ONCE(drm_dev, max_cursor_size < VSDC_MIN_CURSOR_SIZE ||
				      max_cursor_size > VSDC_MAX_CURSOR_SIZE))
		return ERR_PTR(-EINVAL);

	plane = drmm_universal_plane_alloc(drm_dev, struct drm_plane, dev, 0,
					   &vs_cursor_plane_funcs,
					   vs_cursor_plane_formats,
					   ARRAY_SIZE(vs_cursor_plane_formats),
					   vs_cursor_plane_modifiers,
					   DRM_PLANE_TYPE_CURSOR,
					   NULL);

	if (IS_ERR(plane))
		return plane;

	drm_plane_helper_add(plane, &vs_cursor_plane_helper_funcs);

	return plane;
}