drivers/gpu/drm/kmb/kmb_crtc.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright © 2018-2020 Intel Corporation
  */

 #include <linux/clk.h>

 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_print.h>
 #include <drm/drm_vblank.h>
 #include <drm/drm_modeset_helper_vtables.h>

 #include "kmb_drv.h"
 #include "kmb_dsi.h"
 #include "kmb_plane.h"
 #include "kmb_regs.h"

 struct kmb_crtc_timing {
 	u32 vfront_porch;
 	u32 vback_porch;
 	u32 vsync_len;
 	u32 hfront_porch;
 	u32 hback_porch;
 	u32 hsync_len;
 };

 static int kmb_crtc_enable_vblank(struct drm_crtc *crtc)
 {
 	struct drm_device *dev = crtc->dev;
 	struct kmb_drm_private *kmb = to_kmb(dev);

 	/* Clear interrupt */
 	kmb_write_lcd(kmb, LCD_INT_CLEAR, LCD_INT_VERT_COMP);
 	/* Set which interval to generate vertical interrupt */
 	kmb_write_lcd(kmb, LCD_VSTATUS_COMPARE,
 		      LCD_VSTATUS_COMPARE_VSYNC);
 	/* Enable vertical interrupt */
 	kmb_set_bitmask_lcd(kmb, LCD_INT_ENABLE,
 			    LCD_INT_VERT_COMP);
 	return 0;
 }

 static void kmb_crtc_disable_vblank(struct drm_crtc *crtc)
 {
 	struct drm_device *dev = crtc->dev;
 	struct kmb_drm_private *kmb = to_kmb(dev);

 	/* Clear interrupt */
 	kmb_write_lcd(kmb, LCD_INT_CLEAR, LCD_INT_VERT_COMP);
 	/* Disable vertical interrupt */
 	kmb_clr_bitmask_lcd(kmb, LCD_INT_ENABLE,
 			    LCD_INT_VERT_COMP);
 }

 static const struct drm_crtc_funcs kmb_crtc_funcs = {
 	.destroy = drm_crtc_cleanup,
 	.set_config = drm_atomic_helper_set_config,
 	.page_flip = drm_atomic_helper_page_flip,
 	.reset = drm_atomic_helper_crtc_reset,
 	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
 	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
 	.enable_vblank = kmb_crtc_enable_vblank,
 	.disable_vblank = kmb_crtc_disable_vblank,
 };

 static void kmb_crtc_set_mode(struct drm_crtc *crtc,
 			      struct drm_atomic_state *old_state)
 {
 	struct drm_device *dev = crtc->dev;
 	struct drm_display_mode *m = &crtc->state->adjusted_mode;
 	struct kmb_crtc_timing vm;
 	struct kmb_drm_private *kmb = to_kmb(dev);
 	unsigned int val = 0;

 	/* Initialize mipi */
 	kmb_dsi_mode_set(kmb->kmb_dsi, m, kmb->sys_clk_mhz, old_state);
 	drm_info(dev,
 		 "vfp= %d vbp= %d vsync_len=%d hfp=%d hbp=%d hsync_len=%d\n",
 		 m->crtc_vsync_start - m->crtc_vdisplay,
 		 m->crtc_vtotal - m->crtc_vsync_end,
 		 m->crtc_vsync_end - m->crtc_vsync_start,
 		 m->crtc_hsync_start - m->crtc_hdisplay,
 		 m->crtc_htotal - m->crtc_hsync_end,
 		 m->crtc_hsync_end - m->crtc_hsync_start);
 	val = kmb_read_lcd(kmb, LCD_INT_ENABLE);
 	kmb_clr_bitmask_lcd(kmb, LCD_INT_ENABLE, val);
 	kmb_set_bitmask_lcd(kmb, LCD_INT_CLEAR, ~0x0);
 	vm.vfront_porch = 2;
 	vm.vback_porch = 2;
 	vm.vsync_len = 8;
 	vm.hfront_porch = 0;
 	vm.hback_porch = 0;
 	vm.hsync_len = 28;

 	drm_dbg(dev, "%s : %dactive height= %d vbp=%d vfp=%d vsync-w=%d h-active=%d h-bp=%d h-fp=%d hsync-l=%d",
 		__func__, __LINE__,
 			m->crtc_vdisplay, vm.vback_porch, vm.vfront_porch,
 			vm.vsync_len, m->crtc_hdisplay, vm.hback_porch,
 			vm.hfront_porch, vm.hsync_len);
 	kmb_write_lcd(kmb, LCD_V_ACTIVEHEIGHT,
 		      m->crtc_vdisplay - 1);
 	kmb_write_lcd(kmb, LCD_V_BACKPORCH, vm.vback_porch);
 	kmb_write_lcd(kmb, LCD_V_FRONTPORCH, vm.vfront_porch);
 	kmb_write_lcd(kmb, LCD_VSYNC_WIDTH, vm.vsync_len - 1);
 	kmb_write_lcd(kmb, LCD_H_ACTIVEWIDTH,
 		      m->crtc_hdisplay - 1);
 	kmb_write_lcd(kmb, LCD_H_BACKPORCH, vm.hback_porch);
 	kmb_write_lcd(kmb, LCD_H_FRONTPORCH, vm.hfront_porch);
 	kmb_write_lcd(kmb, LCD_HSYNC_WIDTH, vm.hsync_len - 1);
 	/* This is hardcoded as 0 in the Myriadx code */
 	kmb_write_lcd(kmb, LCD_VSYNC_START, 0);
 	kmb_write_lcd(kmb, LCD_VSYNC_END, 0);
 	/* Back ground color */
 	kmb_write_lcd(kmb, LCD_BG_COLOUR_LS, 0x4);
 	if (m->flags == DRM_MODE_FLAG_INTERLACE) {
 		kmb_write_lcd(kmb,
 			      LCD_VSYNC_WIDTH_EVEN, vm.vsync_len - 1);
 		kmb_write_lcd(kmb,
 			      LCD_V_BACKPORCH_EVEN, vm.vback_porch);
 		kmb_write_lcd(kmb,
 			      LCD_V_FRONTPORCH_EVEN, vm.vfront_porch);
 		kmb_write_lcd(kmb, LCD_V_ACTIVEHEIGHT_EVEN,
 			      m->crtc_vdisplay - 1);
 		/* This is hardcoded as 10 in the Myriadx code */
 		kmb_write_lcd(kmb, LCD_VSYNC_START_EVEN, 10);
 		kmb_write_lcd(kmb, LCD_VSYNC_END_EVEN, 10);
 	}
 	kmb_write_lcd(kmb, LCD_TIMING_GEN_TRIG, 1);
 	kmb_set_bitmask_lcd(kmb, LCD_CONTROL, LCD_CTRL_ENABLE);
 	kmb_set_bitmask_lcd(kmb, LCD_INT_ENABLE, val);
 }

 static void kmb_crtc_atomic_enable(struct drm_crtc *crtc,
 				   struct drm_atomic_state *state)
 {
 	struct kmb_drm_private *kmb = crtc_to_kmb_priv(crtc);

 	clk_prepare_enable(kmb->kmb_clk.clk_lcd);
 	kmb_crtc_set_mode(crtc, state);
 	drm_crtc_vblank_on(crtc);
 }

 static void kmb_crtc_atomic_disable(struct drm_crtc *crtc,
 				    struct drm_atomic_state *state)
 {
 	struct kmb_drm_private *kmb = crtc_to_kmb_priv(crtc);
 	struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state, crtc);

 	/* due to hw limitations, planes need to be off when crtc is off */
 	drm_atomic_helper_disable_planes_on_crtc(old_state, false);

 	drm_crtc_vblank_off(crtc);
 	clk_disable_unprepare(kmb->kmb_clk.clk_lcd);
 }

 static void kmb_crtc_atomic_begin(struct drm_crtc *crtc,
 				  struct drm_atomic_state *state)
 {
 	struct drm_device *dev = crtc->dev;
 	struct kmb_drm_private *kmb = to_kmb(dev);

 	kmb_clr_bitmask_lcd(kmb, LCD_INT_ENABLE,
 			    LCD_INT_VERT_COMP);
 }

 static void kmb_crtc_atomic_flush(struct drm_crtc *crtc,
 				  struct drm_atomic_state *state)
 {
 	struct drm_device *dev = crtc->dev;
 	struct kmb_drm_private *kmb = to_kmb(dev);

 	kmb_set_bitmask_lcd(kmb, LCD_INT_ENABLE,
 			    LCD_INT_VERT_COMP);

 	spin_lock_irq(&crtc->dev->event_lock);
 	if (crtc->state->event) {
 		if (drm_crtc_vblank_get(crtc) == 0)
 			drm_crtc_arm_vblank_event(crtc, crtc->state->event);
 		else
 			drm_crtc_send_vblank_event(crtc, crtc->state->event);
 	}
 	crtc->state->event = NULL;
 	spin_unlock_irq(&crtc->dev->event_lock);
 }

 static enum drm_mode_status
 		kmb_crtc_mode_valid(struct drm_crtc *crtc,
 				    const struct drm_display_mode *mode)
 {
 	int refresh;
 	struct drm_device *dev = crtc->dev;
 	int vfp = mode->vsync_start - mode->vdisplay;

 	if (mode->vdisplay < KMB_CRTC_MAX_HEIGHT) {
 		drm_dbg(dev, "height = %d less than %d",
 			mode->vdisplay, KMB_CRTC_MAX_HEIGHT);
 		return MODE_BAD_VVALUE;
 	}
 	if (mode->hdisplay < KMB_CRTC_MAX_WIDTH) {
 		drm_dbg(dev, "width = %d less than %d",
 			mode->hdisplay, KMB_CRTC_MAX_WIDTH);
 		return MODE_BAD_HVALUE;
 	}
 	refresh = drm_mode_vrefresh(mode);
 	if (refresh < KMB_MIN_VREFRESH || refresh > KMB_MAX_VREFRESH) {
 		drm_dbg(dev, "refresh = %d less than %d or greater than %d",
 			refresh, KMB_MIN_VREFRESH, KMB_MAX_VREFRESH);
 		return MODE_BAD;
 	}

 	if (vfp < KMB_CRTC_MIN_VFP) {
 		drm_dbg(dev, "vfp = %d less than %d", vfp, KMB_CRTC_MIN_VFP);
 		return MODE_BAD;
 	}

 	return MODE_OK;
 }

 static const struct drm_crtc_helper_funcs kmb_crtc_helper_funcs = {
 	.atomic_begin = kmb_crtc_atomic_begin,
 	.atomic_enable = kmb_crtc_atomic_enable,
 	.atomic_disable = kmb_crtc_atomic_disable,
 	.atomic_flush = kmb_crtc_atomic_flush,
 	.mode_valid = kmb_crtc_mode_valid,
 };

 int kmb_setup_crtc(struct drm_device *drm)
 {
 	struct kmb_drm_private *kmb = to_kmb(drm);
 	struct kmb_plane *primary;
 	int ret;

 	primary = kmb_plane_init(drm);
 	if (IS_ERR(primary))
 		return PTR_ERR(primary);

 	ret = drm_crtc_init_with_planes(drm, &kmb->crtc, &primary->base_plane,
 					NULL, &kmb_crtc_funcs, NULL);
 	if (ret) {
 		kmb_plane_destroy(&primary->base_plane);
 		return ret;
 	}

 	drm_crtc_helper_add(&kmb->crtc, &kmb_crtc_helper_funcs);
 	return 0;
 }
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Copyright © 2018-2020 Intel Corporation
	*/

	#include <linux/clk.h>

	#include <drm/drm_atomic.h>
	#include <drm/drm_atomic_helper.h>
	#include <drm/drm_crtc.h>
	#include <drm/drm_crtc_helper.h>
	#include <drm/drm_print.h>
	#include <drm/drm_vblank.h>
	#include <drm/drm_modeset_helper_vtables.h>

	#include "kmb_drv.h"
	#include "kmb_dsi.h"
	#include "kmb_plane.h"
	#include "kmb_regs.h"

	struct kmb_crtc_timing {
	u32 vfront_porch;
	u32 vback_porch;
	u32 vsync_len;
	u32 hfront_porch;
	u32 hback_porch;
	u32 hsync_len;
	};

	static int kmb_crtc_enable_vblank(struct drm_crtc *crtc)
	{
	struct drm_device *dev = crtc->dev;
	struct kmb_drm_private *kmb = to_kmb(dev);

	/* Clear interrupt */
	kmb_write_lcd(kmb, LCD_INT_CLEAR, LCD_INT_VERT_COMP);
	/* Set which interval to generate vertical interrupt */
	kmb_write_lcd(kmb, LCD_VSTATUS_COMPARE,
	LCD_VSTATUS_COMPARE_VSYNC);
	/* Enable vertical interrupt */
	kmb_set_bitmask_lcd(kmb, LCD_INT_ENABLE,
	LCD_INT_VERT_COMP);
	return 0;
	}

	static void kmb_crtc_disable_vblank(struct drm_crtc *crtc)
	{
	struct drm_device *dev = crtc->dev;
	struct kmb_drm_private *kmb = to_kmb(dev);

	/* Clear interrupt */
	kmb_write_lcd(kmb, LCD_INT_CLEAR, LCD_INT_VERT_COMP);
	/* Disable vertical interrupt */
	kmb_clr_bitmask_lcd(kmb, LCD_INT_ENABLE,
	LCD_INT_VERT_COMP);
	}

	static const struct drm_crtc_funcs kmb_crtc_funcs = {
	.destroy = drm_crtc_cleanup,
	.set_config = drm_atomic_helper_set_config,
	.page_flip = drm_atomic_helper_page_flip,
	.reset = drm_atomic_helper_crtc_reset,
	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
	.enable_vblank = kmb_crtc_enable_vblank,
	.disable_vblank = kmb_crtc_disable_vblank,
	};

	static void kmb_crtc_set_mode(struct drm_crtc *crtc,
	struct drm_atomic_state *old_state)
	{
	struct drm_device *dev = crtc->dev;
	struct drm_display_mode *m = &crtc->state->adjusted_mode;
	struct kmb_crtc_timing vm;
	struct kmb_drm_private *kmb = to_kmb(dev);
	unsigned int val = 0;

	/* Initialize mipi */
	kmb_dsi_mode_set(kmb->kmb_dsi, m, kmb->sys_clk_mhz, old_state);
	drm_info(dev,
	"vfp= %d vbp= %d vsync_len=%d hfp=%d hbp=%d hsync_len=%d\n",
	m->crtc_vsync_start - m->crtc_vdisplay,
	m->crtc_vtotal - m->crtc_vsync_end,
	m->crtc_vsync_end - m->crtc_vsync_start,
	m->crtc_hsync_start - m->crtc_hdisplay,
	m->crtc_htotal - m->crtc_hsync_end,
	m->crtc_hsync_end - m->crtc_hsync_start);
	val = kmb_read_lcd(kmb, LCD_INT_ENABLE);
	kmb_clr_bitmask_lcd(kmb, LCD_INT_ENABLE, val);
	kmb_set_bitmask_lcd(kmb, LCD_INT_CLEAR, ~0x0);
	vm.vfront_porch = 2;
	vm.vback_porch = 2;
	vm.vsync_len = 8;
	vm.hfront_porch = 0;
	vm.hback_porch = 0;
	vm.hsync_len = 28;

	drm_dbg(dev, "%s : %dactive height= %d vbp=%d vfp=%d vsync-w=%d h-active=%d h-bp=%d h-fp=%d hsync-l=%d",
	__func__, __LINE__,
	m->crtc_vdisplay, vm.vback_porch, vm.vfront_porch,
	vm.vsync_len, m->crtc_hdisplay, vm.hback_porch,
	vm.hfront_porch, vm.hsync_len);
	kmb_write_lcd(kmb, LCD_V_ACTIVEHEIGHT,
	m->crtc_vdisplay - 1);
	kmb_write_lcd(kmb, LCD_V_BACKPORCH, vm.vback_porch);
	kmb_write_lcd(kmb, LCD_V_FRONTPORCH, vm.vfront_porch);
	kmb_write_lcd(kmb, LCD_VSYNC_WIDTH, vm.vsync_len - 1);
	kmb_write_lcd(kmb, LCD_H_ACTIVEWIDTH,
	m->crtc_hdisplay - 1);
	kmb_write_lcd(kmb, LCD_H_BACKPORCH, vm.hback_porch);
	kmb_write_lcd(kmb, LCD_H_FRONTPORCH, vm.hfront_porch);
	kmb_write_lcd(kmb, LCD_HSYNC_WIDTH, vm.hsync_len - 1);
	/* This is hardcoded as 0 in the Myriadx code */
	kmb_write_lcd(kmb, LCD_VSYNC_START, 0);
	kmb_write_lcd(kmb, LCD_VSYNC_END, 0);
	/* Back ground color */
	kmb_write_lcd(kmb, LCD_BG_COLOUR_LS, 0x4);
	if (m->flags == DRM_MODE_FLAG_INTERLACE) {
	kmb_write_lcd(kmb,
	LCD_VSYNC_WIDTH_EVEN, vm.vsync_len - 1);
	kmb_write_lcd(kmb,
	LCD_V_BACKPORCH_EVEN, vm.vback_porch);
	kmb_write_lcd(kmb,
	LCD_V_FRONTPORCH_EVEN, vm.vfront_porch);
	kmb_write_lcd(kmb, LCD_V_ACTIVEHEIGHT_EVEN,
	m->crtc_vdisplay - 1);
	/* This is hardcoded as 10 in the Myriadx code */
	kmb_write_lcd(kmb, LCD_VSYNC_START_EVEN, 10);
	kmb_write_lcd(kmb, LCD_VSYNC_END_EVEN, 10);
	}
	kmb_write_lcd(kmb, LCD_TIMING_GEN_TRIG, 1);
	kmb_set_bitmask_lcd(kmb, LCD_CONTROL, LCD_CTRL_ENABLE);
	kmb_set_bitmask_lcd(kmb, LCD_INT_ENABLE, val);
	}

	static void kmb_crtc_atomic_enable(struct drm_crtc *crtc,
	struct drm_atomic_state *state)
	{
	struct kmb_drm_private *kmb = crtc_to_kmb_priv(crtc);

	clk_prepare_enable(kmb->kmb_clk.clk_lcd);
	kmb_crtc_set_mode(crtc, state);
	drm_crtc_vblank_on(crtc);
	}

	static void kmb_crtc_atomic_disable(struct drm_crtc *crtc,
	struct drm_atomic_state *state)
	{
	struct kmb_drm_private *kmb = crtc_to_kmb_priv(crtc);
	struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state, crtc);

	/* due to hw limitations, planes need to be off when crtc is off */
	drm_atomic_helper_disable_planes_on_crtc(old_state, false);

	drm_crtc_vblank_off(crtc);
	clk_disable_unprepare(kmb->kmb_clk.clk_lcd);
	}

	static void kmb_crtc_atomic_begin(struct drm_crtc *crtc,
	struct drm_atomic_state *state)
	{
	struct drm_device *dev = crtc->dev;
	struct kmb_drm_private *kmb = to_kmb(dev);

	kmb_clr_bitmask_lcd(kmb, LCD_INT_ENABLE,
	LCD_INT_VERT_COMP);
	}

	static void kmb_crtc_atomic_flush(struct drm_crtc *crtc,
	struct drm_atomic_state *state)
	{
	struct drm_device *dev = crtc->dev;
	struct kmb_drm_private *kmb = to_kmb(dev);

	kmb_set_bitmask_lcd(kmb, LCD_INT_ENABLE,
	LCD_INT_VERT_COMP);

	spin_lock_irq(&crtc->dev->event_lock);
	if (crtc->state->event) {
	if (drm_crtc_vblank_get(crtc) == 0)
	drm_crtc_arm_vblank_event(crtc, crtc->state->event);
	else
	drm_crtc_send_vblank_event(crtc, crtc->state->event);
	}
	crtc->state->event = NULL;
	spin_unlock_irq(&crtc->dev->event_lock);
	}

	static enum drm_mode_status
	kmb_crtc_mode_valid(struct drm_crtc *crtc,
	const struct drm_display_mode *mode)
	{
	int refresh;
	struct drm_device *dev = crtc->dev;
	int vfp = mode->vsync_start - mode->vdisplay;

	if (mode->vdisplay < KMB_CRTC_MAX_HEIGHT) {
	drm_dbg(dev, "height = %d less than %d",
	mode->vdisplay, KMB_CRTC_MAX_HEIGHT);
	return MODE_BAD_VVALUE;
	}
	if (mode->hdisplay < KMB_CRTC_MAX_WIDTH) {
	drm_dbg(dev, "width = %d less than %d",
	mode->hdisplay, KMB_CRTC_MAX_WIDTH);
	return MODE_BAD_HVALUE;
	}
	refresh = drm_mode_vrefresh(mode);
	if (refresh < KMB_MIN_VREFRESH \|\| refresh > KMB_MAX_VREFRESH) {
	drm_dbg(dev, "refresh = %d less than %d or greater than %d",
	refresh, KMB_MIN_VREFRESH, KMB_MAX_VREFRESH);
	return MODE_BAD;
	}

	if (vfp < KMB_CRTC_MIN_VFP) {
	drm_dbg(dev, "vfp = %d less than %d", vfp, KMB_CRTC_MIN_VFP);
	return MODE_BAD;
	}

	return MODE_OK;
	}

	static const struct drm_crtc_helper_funcs kmb_crtc_helper_funcs = {
	.atomic_begin = kmb_crtc_atomic_begin,
	.atomic_enable = kmb_crtc_atomic_enable,
	.atomic_disable = kmb_crtc_atomic_disable,
	.atomic_flush = kmb_crtc_atomic_flush,
	.mode_valid = kmb_crtc_mode_valid,
	};

	int kmb_setup_crtc(struct drm_device *drm)
	{
	struct kmb_drm_private *kmb = to_kmb(drm);
	struct kmb_plane *primary;
	int ret;

	primary = kmb_plane_init(drm);
	if (IS_ERR(primary))
	return PTR_ERR(primary);

	ret = drm_crtc_init_with_planes(drm, &kmb->crtc, &primary->base_plane,
	NULL, &kmb_crtc_funcs, NULL);
	if (ret) {
	kmb_plane_destroy(&primary->base_plane);
	return ret;
	}

	drm_crtc_helper_add(&kmb->crtc, &kmb_crtc_helper_funcs);
	return 0;
	}