xref: /OK3568_Linux_fs/kernel/drivers/gpu/drm/rockchip/rockchip_drm_fb.c (revision 4882a59341e53eb6f0b4789bf948001014eff981)

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
 * Author:Mark Yao <mark.yao@rock-chips.com>
 */

#include <linux/kernel.h>
#include <linux/devfreq.h>

#include <drm/drm.h>
#include <drm/drm_atomic.h>
#include <drm/drm_damage_helper.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_probe_helper.h>
#include <soc/rockchip/rockchip_dmc.h>

#include "rockchip_drm_drv.h"
#include "rockchip_drm_fb.h"
#include "rockchip_drm_gem.h"
#include "rockchip_drm_logo.h"

static bool is_rockchip_logo_fb(struct drm_framebuffer *fb)
{
	return fb->flags & ROCKCHIP_DRM_MODE_LOGO_FB ? true : false;
}

static void __rockchip_drm_fb_destroy(struct drm_framebuffer *fb)
{
	int i = 0;

	drm_framebuffer_cleanup(fb);

	if (is_rockchip_logo_fb(fb)) {
		struct rockchip_drm_logo_fb *rockchip_logo_fb = to_rockchip_logo_fb(fb);

#ifndef MODULE
		rockchip_free_loader_memory(fb->dev);
#endif
		drm_gem_object_release(rockchip_logo_fb->fb.obj[0]);
		kfree(rockchip_logo_fb);
	} else {
		for (i = 0; i < 4; i++) {
			if (fb->obj[i])
				drm_gem_object_put(fb->obj[i]);
		}

		kfree(fb);
	}
}

static void rockchip_drm_fb_destroy_work(struct work_struct *work)
{
	struct rockchip_drm_logo_fb *fb;

	fb = container_of(to_delayed_work(work), struct rockchip_drm_logo_fb, destroy_work);

	__rockchip_drm_fb_destroy(&fb->fb);
}

static void rockchip_drm_fb_destroy(struct drm_framebuffer *fb)
{

	if (is_rockchip_logo_fb(fb)) {
		struct rockchip_drm_logo_fb *rockchip_logo_fb = to_rockchip_logo_fb(fb);

		schedule_delayed_work(&rockchip_logo_fb->destroy_work, HZ);
	} else {
		__rockchip_drm_fb_destroy(fb);
	}
}

static int rockchip_drm_gem_fb_create_handle(struct drm_framebuffer *fb,
					     struct drm_file *file,
					     unsigned int *handle)
{
	if (is_rockchip_logo_fb(fb))
		return -EOPNOTSUPP;

	return drm_gem_fb_create_handle(fb, file, handle);
}

static const struct drm_framebuffer_funcs rockchip_drm_fb_funcs = {
	.destroy       = rockchip_drm_fb_destroy,
	.create_handle = rockchip_drm_gem_fb_create_handle,
};

struct drm_framebuffer *
rockchip_fb_alloc(struct drm_device *dev, const struct drm_mode_fb_cmd2 *mode_cmd,
		  struct drm_gem_object **obj, unsigned int num_planes)
{
	struct drm_framebuffer *fb;
	int ret;
	int i;

	fb = kzalloc(sizeof(*fb), GFP_KERNEL);
	if (!fb)
		return ERR_PTR(-ENOMEM);

	drm_helper_mode_fill_fb_struct(dev, fb, mode_cmd);

	for (i = 0; i < num_planes; i++)
		fb->obj[i] = obj[i];

	ret = drm_framebuffer_init(dev, fb, &rockchip_drm_fb_funcs);
	if (ret) {
		DRM_DEV_ERROR(dev->dev,
			      "Failed to initialize framebuffer: %d\n",
			      ret);
		kfree(fb);
		return ERR_PTR(ret);
	}

	return fb;
}

struct drm_framebuffer *
rockchip_drm_logo_fb_alloc(struct drm_device *dev, const struct drm_mode_fb_cmd2 *mode_cmd,
			   struct rockchip_logo *logo)
{
	int ret = 0;
	struct rockchip_drm_logo_fb *rockchip_logo_fb;
	struct drm_framebuffer *fb;

	rockchip_logo_fb = kzalloc(sizeof(*rockchip_logo_fb), GFP_KERNEL);
	if (!rockchip_logo_fb)
		return ERR_PTR(-ENOMEM);
	fb = &rockchip_logo_fb->fb;

	drm_helper_mode_fill_fb_struct(dev, fb, mode_cmd);

	ret = drm_framebuffer_init(dev, fb, &rockchip_drm_fb_funcs);
	if (ret) {
		DRM_DEV_ERROR(dev->dev,
			      "Failed to initialize rockchip logo fb: %d\n",
			      ret);
		kfree(rockchip_logo_fb);
		return ERR_PTR(ret);
	}

	fb->flags |= ROCKCHIP_DRM_MODE_LOGO_FB;
	rockchip_logo_fb->logo = logo;
	rockchip_logo_fb->fb.obj[0] = &rockchip_logo_fb->rk_obj.base;
	drm_gem_object_init(dev, rockchip_logo_fb->fb.obj[0], PAGE_ALIGN(logo->size));
	rockchip_logo_fb->rk_obj.dma_addr = logo->dma_addr;
	rockchip_logo_fb->rk_obj.kvaddr = logo->kvaddr;
	logo->count++;
	INIT_DELAYED_WORK(&rockchip_logo_fb->destroy_work, rockchip_drm_fb_destroy_work);
	return &rockchip_logo_fb->fb;
}

static int rockchip_drm_bandwidth_atomic_check(struct drm_device *dev,
					       struct drm_atomic_state *state,
					       struct dmcfreq_vop_info *vop_bw_info)
{
	struct rockchip_drm_private *priv = dev->dev_private;
	struct drm_crtc_state *old_crtc_state;
	const struct rockchip_crtc_funcs *funcs;
	struct drm_crtc *crtc;
	int i;

	vop_bw_info->line_bw_mbyte = 0;
	vop_bw_info->frame_bw_mbyte = 0;
	vop_bw_info->plane_num = 0;
	vop_bw_info->plane_num_4k = 0;

	for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
		funcs = priv->crtc_funcs[drm_crtc_index(crtc)];

		if (funcs && funcs->bandwidth)
			funcs->bandwidth(crtc, old_crtc_state, vop_bw_info);
	}

	return 0;
}

static void drm_atomic_helper_connector_commit(struct drm_device *dev,
					       struct drm_atomic_state *old_state)
{
	struct drm_connector *connector;
	struct drm_connector_state *new_conn_state;
	int i;

	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
		const struct drm_connector_helper_funcs *funcs;

		funcs = connector->helper_private;
		if (!funcs->atomic_commit)
			continue;

		funcs->atomic_commit(connector, new_conn_state);
	}
}

/**
 * rockchip_drm_atomic_helper_commit_tail_rpm - commit atomic update to hardware
 * @old_state: new modeset state to be committed
 *
 * This is an alternative implementation for the
 * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
 * that support runtime_pm or need the CRTC to be enabled to perform a
 * commit. Otherwise, one should use the default implementation
 * drm_atomic_helper_commit_tail().
 */
static void rockchip_drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
{
	struct drm_device *dev = old_state->dev;
	struct rockchip_drm_private *prv = dev->dev_private;
	struct dmcfreq_vop_info vop_bw_info;

	drm_atomic_helper_commit_modeset_disables(dev, old_state);

	drm_atomic_helper_commit_modeset_enables(dev, old_state);

	rockchip_drm_bandwidth_atomic_check(dev, old_state, &vop_bw_info);

	rockchip_dmcfreq_vop_bandwidth_update(&vop_bw_info);

	mutex_lock(&prv->ovl_lock);
	drm_atomic_helper_commit_planes(dev, old_state, DRM_PLANE_COMMIT_ACTIVE_ONLY);
	mutex_unlock(&prv->ovl_lock);

	drm_atomic_helper_fake_vblank(old_state);

	drm_atomic_helper_connector_commit(dev, old_state);

	drm_atomic_helper_commit_hw_done(old_state);

	drm_atomic_helper_wait_for_vblanks(dev, old_state);

	drm_atomic_helper_cleanup_planes(dev, old_state);
}

static const struct drm_mode_config_helper_funcs rockchip_mode_config_helpers = {
	.atomic_commit_tail = rockchip_drm_atomic_helper_commit_tail_rpm,
};

static struct drm_framebuffer *
rockchip_fb_create(struct drm_device *dev, struct drm_file *file,
		   const struct drm_mode_fb_cmd2 *mode_cmd)
{
	struct drm_afbc_framebuffer *afbc_fb;
	const struct drm_format_info *info;
	int ret, i;

	info = drm_get_format_info(dev, mode_cmd);
	if (!info)
		return ERR_PTR(-ENOMEM);

	for (i = 0; i < info->num_planes; ++i) {
		if (mode_cmd->pitches[i] % 4) {
			DRM_DEV_ERROR_RATELIMITED(dev->dev,
				"fb pitch[%d] must be 4 byte aligned: %d\n", i, mode_cmd->pitches[i]);
			return ERR_PTR(-EINVAL);
		}
	}

	afbc_fb = kzalloc(sizeof(*afbc_fb), GFP_KERNEL);
	if (!afbc_fb)
		return ERR_PTR(-ENOMEM);

	ret = drm_gem_fb_init_with_funcs(dev, &afbc_fb->base, file, mode_cmd,
					 &rockchip_drm_fb_funcs);
	if (ret) {
		kfree(afbc_fb);
		return ERR_PTR(ret);
	}

	if (drm_is_afbc(mode_cmd->modifier[0])) {
		ret = drm_gem_fb_afbc_init(dev, mode_cmd, afbc_fb);
		if (ret) {
			struct drm_gem_object **obj = afbc_fb->base.obj;

			for (i = 0; i < info->num_planes; ++i)
				drm_gem_object_put(obj[i]);

			kfree(afbc_fb);
			return ERR_PTR(ret);
		}
	}

	return &afbc_fb->base;
}

static void rockchip_drm_output_poll_changed(struct drm_device *dev)
{
	struct rockchip_drm_private *private = dev->dev_private;
	struct drm_fb_helper *fb_helper = private->fbdev_helper;

	if (fb_helper && dev->mode_config.poll_enabled && !private->loader_protect)
		drm_fb_helper_hotplug_event(fb_helper);
}

static const struct drm_mode_config_funcs rockchip_drm_mode_config_funcs = {
	.fb_create = rockchip_fb_create,
	.output_poll_changed = rockchip_drm_output_poll_changed,
	.atomic_check = drm_atomic_helper_check,
	.atomic_commit = drm_atomic_helper_commit,
};

struct drm_framebuffer *
rockchip_drm_framebuffer_init(struct drm_device *dev,
			      const struct drm_mode_fb_cmd2 *mode_cmd,
			      struct drm_gem_object *obj)
{
	struct drm_framebuffer *fb;

	fb = rockchip_fb_alloc(dev, mode_cmd, &obj, 1);
	if (IS_ERR(fb))
		return ERR_CAST(fb);

	return fb;
}

void rockchip_drm_mode_config_init(struct drm_device *dev)
{
	dev->mode_config.min_width = 0;
	dev->mode_config.min_height = 0;

	/*
	 * set max width and height as default value(16384x16384).
	 * this value would be used to check framebuffer size limitation
	 * at drm_mode_addfb().
	 */
	dev->mode_config.max_width = 16384;
	dev->mode_config.max_height = 16384;
	dev->mode_config.async_page_flip = true;

	dev->mode_config.funcs = &rockchip_drm_mode_config_funcs;
	dev->mode_config.helper_private = &rockchip_mode_config_helpers;
}