linux_dsm_epyc7002/drivers/gpu/drm/mgag200/mgag200_cursor.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright 2013 Matrox Graphics
 *
 * Author: Christopher Harvey <charvey@matrox.com>
 */

#include <linux/pci.h>

#include "mgag200_drv.h"

static bool warn_transparent = true;
static bool warn_palette = true;

static int mgag200_cursor_update(struct mga_device *mdev, void *dst, void *src,
				 unsigned int width, unsigned int height)
{
	struct drm_device *dev = mdev->dev;
	unsigned int i, row, col;
	uint32_t colour_set[16];
	uint32_t *next_space = &colour_set[0];
	uint32_t *palette_iter;
	uint32_t this_colour;
	bool found = false;
	int colour_count = 0;
	u8 reg_index;
	u8 this_row[48];

	memset(&colour_set[0], 0, sizeof(uint32_t)*16);
	/* width*height*4 = 16384 */
	for (i = 0; i < 16384; i += 4) {
		this_colour = ioread32(src + i);
		/* No transparency */
		if (this_colour>>24 != 0xff &&
			this_colour>>24 != 0x0) {
			if (warn_transparent) {
				dev_info(&dev->pdev->dev, "Video card doesn't support cursors with partial transparency.\n");
				dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n");
				warn_transparent = false; /* Only tell the user once. */
			}
			return -EINVAL;
		}
		/* Don't need to store transparent pixels as colours */
		if (this_colour>>24 == 0x0)
			continue;
		found = false;
		for (palette_iter = &colour_set[0]; palette_iter != next_space; palette_iter++) {
			if (*palette_iter == this_colour) {
				found = true;
				break;
			}
		}
		if (found)
			continue;
		/* We only support 4bit paletted cursors */
		if (colour_count >= 16) {
			if (warn_palette) {
				dev_info(&dev->pdev->dev, "Video card only supports cursors with up to 16 colours.\n");
				dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n");
				warn_palette = false; /* Only tell the user once. */
			}
			return -EINVAL;
		}
		*next_space = this_colour;
		next_space++;
		colour_count++;
	}

	/* Program colours from cursor icon into palette */
	for (i = 0; i < colour_count; i++) {
		if (i <= 2)
			reg_index = 0x8 + i*0x4;
		else
			reg_index = 0x60 + i*0x3;
		WREG_DAC(reg_index, colour_set[i] & 0xff);
		WREG_DAC(reg_index+1, colour_set[i]>>8 & 0xff);
		WREG_DAC(reg_index+2, colour_set[i]>>16 & 0xff);
		BUG_ON((colour_set[i]>>24 & 0xff) != 0xff);
	}

	/* now write colour indices into hardware cursor buffer */
	for (row = 0; row < 64; row++) {
		memset(&this_row[0], 0, 48);
		for (col = 0; col < 64; col++) {
			this_colour = ioread32(src + 4*(col + 64*row));
			/* write transparent pixels */
			if (this_colour>>24 == 0x0) {
				this_row[47 - col/8] |= 0x80>>(col%8);
				continue;
			}

			/* write colour index here */
			for (i = 0; i < colour_count; i++) {
				if (colour_set[i] == this_colour) {
					if (col % 2)
						this_row[col/2] |= i<<4;
					else
						this_row[col/2] |= i;
					break;
				}
			}
		}
		memcpy_toio(dst + row*48, &this_row[0], 48);
	}

	return 0;
}

static void mgag200_cursor_set_base(struct mga_device *mdev, u64 address)
{
	u8 addrl = (address >> 10) & 0xff;
	u8 addrh = (address >> 18) & 0x3f;

	/* Program gpu address of cursor buffer */
	WREG_DAC(MGA1064_CURSOR_BASE_ADR_LOW, addrl);
	WREG_DAC(MGA1064_CURSOR_BASE_ADR_HI, addrh);
}

static int mgag200_show_cursor(struct mga_device *mdev, void *src,
			       unsigned int width, unsigned int height)
{
	struct drm_device *dev = mdev->dev;
	struct drm_gem_vram_object *gbo;
	void *dst;
	s64 off;
	int ret;

	gbo = mdev->cursor.gbo[mdev->cursor.next_index];
	if (!gbo) {
		WREG8(MGA_CURPOSXL, 0);
		WREG8(MGA_CURPOSXH, 0);
		return -ENOTSUPP; /* Didn't allocate space for cursors */
	}
	dst = drm_gem_vram_vmap(gbo);
	if (IS_ERR(dst)) {
		ret = PTR_ERR(dst);
		dev_err(&dev->pdev->dev,
			"failed to map cursor updates: %d\n", ret);
		return ret;
	}
	off = drm_gem_vram_offset(gbo);
	if (off < 0) {
		ret = (int)off;
		dev_err(&dev->pdev->dev,
			"failed to get cursor scanout address: %d\n", ret);
		goto err_drm_gem_vram_vunmap;
	}

	ret = mgag200_cursor_update(mdev, dst, src, width, height);
	if (ret)
		goto err_drm_gem_vram_vunmap;
	mgag200_cursor_set_base(mdev, off);

	/* Adjust cursor control register to turn on the cursor */
	WREG_DAC(MGA1064_CURSOR_CTL, 4); /* 16-colour palletized cursor mode */

	drm_gem_vram_vunmap(gbo, dst);

	++mdev->cursor.next_index;
	mdev->cursor.next_index %= ARRAY_SIZE(mdev->cursor.gbo);

	return 0;

err_drm_gem_vram_vunmap:
	drm_gem_vram_vunmap(gbo, dst);
	return ret;
}

/*
 * Hide the cursor off screen. We can't disable the cursor hardware because
 * it takes too long to re-activate and causes momentary corruption.
 */
static void mgag200_hide_cursor(struct mga_device *mdev)
{
	WREG8(MGA_CURPOSXL, 0);
	WREG8(MGA_CURPOSXH, 0);
}

static void mgag200_move_cursor(struct mga_device *mdev, int x, int y)
{
	if (WARN_ON(x <= 0))
		return;
	if (WARN_ON(y <= 0))
		return;
	if (WARN_ON(x & ~0xffff))
		return;
	if (WARN_ON(y & ~0xffff))
		return;

	WREG8(MGA_CURPOSXL, x & 0xff);
	WREG8(MGA_CURPOSXH, (x>>8) & 0xff);

	WREG8(MGA_CURPOSYL, y & 0xff);
	WREG8(MGA_CURPOSYH, (y>>8) & 0xff);
}

int mgag200_cursor_init(struct mga_device *mdev)
{
	struct drm_device *dev = mdev->dev;
	size_t ncursors = ARRAY_SIZE(mdev->cursor.gbo);
	size_t size;
	int ret;
	size_t i;
	struct drm_gem_vram_object *gbo;

	size = roundup(64 * 48, PAGE_SIZE);
	if (size * ncursors > mdev->vram_fb_available)
		return -ENOMEM;

	for (i = 0; i < ncursors; ++i) {
		gbo = drm_gem_vram_create(dev, size, 0);
		if (IS_ERR(gbo)) {
			ret = PTR_ERR(gbo);
			goto err_drm_gem_vram_put;
		}
		ret = drm_gem_vram_pin(gbo, DRM_GEM_VRAM_PL_FLAG_VRAM |
					    DRM_GEM_VRAM_PL_FLAG_TOPDOWN);
		if (ret) {
			drm_gem_vram_put(gbo);
			goto err_drm_gem_vram_put;
		}

		mdev->cursor.gbo[i] = gbo;
	}

	/*
	 * At the high end of video memory, we reserve space for
	 * buffer objects. The cursor plane uses this memory to store
	 * a double-buffered image of the current cursor. Hence, it's
	 * not available for framebuffers.
	 */
	mdev->vram_fb_available -= ncursors * size;

	return 0;

err_drm_gem_vram_put:
	while (i) {
		--i;
		gbo = mdev->cursor.gbo[i];
		drm_gem_vram_unpin(gbo);
		drm_gem_vram_put(gbo);
		mdev->cursor.gbo[i] = NULL;
	}
	return ret;
}

void mgag200_cursor_fini(struct mga_device *mdev)
{
	size_t i;
	struct drm_gem_vram_object *gbo;

	for (i = 0; i < ARRAY_SIZE(mdev->cursor.gbo); ++i) {
		gbo = mdev->cursor.gbo[i];
		drm_gem_vram_unpin(gbo);
		drm_gem_vram_put(gbo);
	}
}

int mgag200_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
			    uint32_t handle, uint32_t width, uint32_t height)
{
	struct drm_device *dev = crtc->dev;
	struct mga_device *mdev = to_mga_device(dev);
	struct drm_gem_object *obj;
	struct drm_gem_vram_object *gbo = NULL;
	int ret;
	u8 *src;

	if (!handle || !file_priv) {
		mgag200_hide_cursor(mdev);
		return 0;
	}

	if (width != 64 || height != 64) {
		WREG8(MGA_CURPOSXL, 0);
		WREG8(MGA_CURPOSXH, 0);
		return -EINVAL;
	}

	obj = drm_gem_object_lookup(file_priv, handle);
	if (!obj)
		return -ENOENT;
	gbo = drm_gem_vram_of_gem(obj);
	src = drm_gem_vram_vmap(gbo);
	if (IS_ERR(src)) {
		ret = PTR_ERR(src);
		dev_err(&dev->pdev->dev,
			"failed to map user buffer updates\n");
		goto err_drm_gem_object_put_unlocked;
	}

	ret = mgag200_show_cursor(mdev, src, width, height);
	if (ret)
		goto err_drm_gem_vram_vunmap;

	/* Now update internal buffer pointers */
	drm_gem_vram_vunmap(gbo, src);
	drm_gem_object_put_unlocked(obj);

	return 0;
err_drm_gem_vram_vunmap:
	drm_gem_vram_vunmap(gbo, src);
err_drm_gem_object_put_unlocked:
	drm_gem_object_put_unlocked(obj);
	return ret;
}

int mgag200_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)
{
	struct mga_device *mdev = to_mga_device(crtc->dev);

	/* Our origin is at (64,64) */
	x += 64;
	y += 64;

	mgag200_move_cursor(mdev, x, y);

	return 0;
}