linux/drivers/gpu/drm/verisilicon/vs_drm.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2025 Icenowy Zheng <uwu@icenowy.me>
 */

#include <linux/aperture.h>
#include <linux/dma-mapping.h>
#include <linux/platform_device.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/console.h>

#include <drm/clients/drm_client_setup.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_drv.h>
#include <drm/drm_dumb_buffers.h>
#include <drm/drm_fbdev_dma.h>
#include <drm/drm_gem_dma_helper.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_of.h>
#include <drm/drm_print.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_vblank.h>

#include "vs_bridge.h"
#include "vs_crtc.h"
#include "vs_dc.h"
#include "vs_dc_top_regs.h"
#include "vs_drm.h"

#define DRIVER_NAME	"verisilicon"
#define DRIVER_DESC	"Verisilicon DC-series display controller driver"
#define DRIVER_MAJOR	1
#define DRIVER_MINOR	0

static int vs_gem_dumb_create(struct drm_file *file_priv,
			      struct drm_device *drm,
			      struct drm_mode_create_dumb *args)
{
	int ret;

	/* The hardware wants 128B-aligned pitches for linear buffers. */
	ret = drm_mode_size_dumb(drm, args, 128, 0);
	if (ret)
		return ret;

	return drm_gem_dma_dumb_create_internal(file_priv, drm, args);
}

DEFINE_DRM_GEM_FOPS(vs_drm_driver_fops);

static const struct drm_driver vs_drm_driver = {
	.driver_features	= DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
	.fops			= &vs_drm_driver_fops,
	.name	= DRIVER_NAME,
	.desc	= DRIVER_DESC,
	.major	= DRIVER_MAJOR,
	.minor	= DRIVER_MINOR,

	/* GEM Operations */
	DRM_GEM_DMA_DRIVER_OPS_WITH_DUMB_CREATE(vs_gem_dumb_create),
	DRM_FBDEV_DMA_DRIVER_OPS,
};

static const struct drm_mode_config_funcs vs_mode_config_funcs = {
	.fb_create		= drm_gem_fb_create,
	.atomic_check		= drm_atomic_helper_check,
	.atomic_commit		= drm_atomic_helper_commit,
};

static struct drm_mode_config_helper_funcs vs_mode_config_helper_funcs = {
	.atomic_commit_tail = drm_atomic_helper_commit_tail,
};

static void vs_mode_config_init(struct drm_device *drm)
{
	drm->mode_config.min_width = 0;
	drm->mode_config.min_height = 0;
	drm->mode_config.max_width = 8192;
	drm->mode_config.max_height = 8192;
	drm->mode_config.funcs = &vs_mode_config_funcs;
	drm->mode_config.helper_private = &vs_mode_config_helper_funcs;
}

int vs_drm_initialize(struct vs_dc *dc, struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct vs_drm_dev *vdrm;
	struct drm_device *drm;
	struct vs_crtc *crtc;
	struct vs_bridge *bridge;
	unsigned int i;
	int ret;

	vdrm = devm_drm_dev_alloc(dev, &vs_drm_driver, struct vs_drm_dev, base);
	if (IS_ERR(vdrm))
		return PTR_ERR(vdrm);

	drm = &vdrm->base;
	vdrm->dc = dc;
	dc->drm_dev = vdrm;

	ret = drmm_mode_config_init(drm);
	if (ret)
		return ret;

	/* Remove early framebuffers (ie. simple-framebuffer) */
	ret = aperture_remove_all_conflicting_devices(DRIVER_NAME);
	if (ret)
		return ret;

	for (i = 0; i < dc->identity.display_count; i++) {
		crtc = vs_crtc_init(drm, dc, i);
		if (IS_ERR(crtc))
			return PTR_ERR(crtc);

		bridge = vs_bridge_init(drm, crtc);
		if (IS_ERR(bridge))
			return PTR_ERR(bridge);

		vdrm->crtcs[i] = crtc;
	}

	ret = drm_vblank_init(drm, dc->identity.display_count);
	if (ret)
		return ret;

	vs_mode_config_init(drm);

	/* Enable connectors polling */
	drm_kms_helper_poll_init(drm);

	drm_mode_config_reset(drm);

	ret = drm_dev_register(drm, 0);
	if (ret)
		goto err_fini_poll;

	drm_client_setup(drm, NULL);

	return 0;

err_fini_poll:
	drm_kms_helper_poll_fini(drm);
	return ret;
}

void vs_drm_finalize(struct vs_dc *dc)
{
	struct vs_drm_dev *vdrm = dc->drm_dev;
	struct drm_device *drm = &vdrm->base;

	drm_dev_unregister(drm);
	drm_kms_helper_poll_fini(drm);
	drm_atomic_helper_shutdown(drm);
	dc->drm_dev = NULL;
}

void vs_drm_shutdown_handler(struct vs_dc *dc)
{
	struct vs_drm_dev *vdrm = dc->drm_dev;

	drm_atomic_helper_shutdown(&vdrm->base);
}

void vs_drm_handle_irq(struct vs_dc *dc, u32 irqs)
{
	unsigned int i;

	for (i = 0; i < dc->identity.display_count; i++) {
		if (irqs & VSDC_TOP_IRQ_VSYNC(i)) {
			irqs &= ~VSDC_TOP_IRQ_VSYNC(i);
			if (dc->drm_dev->crtcs[i])
				drm_crtc_handle_vblank(&dc->drm_dev->crtcs[i]->base);
		}
	}

	if (irqs)
		drm_warn_once(&dc->drm_dev->base,
			      "Unknown Verisilicon DC interrupt 0x%x fired!\n",
			      irqs);
}