Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit d7f1642c90ab5eb2d7c48af0581c993094f97e1a

Authored by Joonyoung Shim 2012-05-17 19:06:32 +0800

Committed by Inki Dae 2012-05-17 19:14:48 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

drm/exynos: add G2D driver

Changelog v3:
- use __u64 instead of pointer in ioctl struct.

The G2D is a 2D graphic accelerator that supports Bit Block Transfer.
This G2D driver is exynos drm specific and supports only G2D(version
4.1) of later Exynos series from Exynos4X12 because supporting DMA.

The G2D is performed by two tasks simply.
1. Configures the rendering parameters, such as foreground color and
   coordinates data by setting the drawing context registers.
2. Start the rendering process by setting thre relevant command
   registers accordingly.

The G2D version 4.1 supports DMA mode as host interface. User can make
command list to reduce HOST(ARM) loads. The contents of The command list
is setted to relevant registers of G2D by DMA.

The command list is composed Header and command sets and Tail.
- Header: The number of command set(4Bytes)
- Command set: Register offset(4Bytes) + Register data(4Bytes)
- Tail: Pointer of base address of the other command list(4Bytes)

By Tail field, the G2D can process many command lists without halt at
one go.

The G2D has following the rendering pipeline.
--> Primitive Drawing --> Rotation --> Clipping --> Bilinear Sampling
--> Color Key --> ROP --> Mask Operation --> Alpha Blending -->
Dithering --> FrameBuffer

And supports various operations from the rendering pipeline.
- copy
- fast solid color fill
- window clipping
- rotation
- flip
- 4 operand raster operation(ROP4)
- masking operation
- alpha blending
- color key
- dithering
- etc

User should make the command list to data and registers needed by
operation to use. The Exynos G2D driver only manages the command lists
received from user. Some registers needs memory base address(physical
address) of image. User doesn't know its physical address, so fills the
gem handle of that memory than address to command sets, then G2D driver
converts it to memory base address.

We adds three ioctls and one event for Exynos G2D.

- ioctls
DRM_EXYNOS_G2D_GET_VER: get the G2D hardware version
DRM_EXYNOS_G2D_SET_CMDLIST: set the command list from user to driver
DRM_EXYNOS_G2D_EXEC: execute the command lists setted to driver

- event
DRM_EXYNOS_G2D_EVENT: event to give notification completion of the
		      command list to user

Signed-off-by: Joonyoung Shim <jy0922.shim@samsung.com>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>

Showing 7 changed files with 1079 additions and 0 deletions Inline Diff

drivers/gpu/drm/exynos/Kconfig
drivers/gpu/drm/exynos/Makefile
drivers/gpu/drm/exynos/exynos_drm_drv.c
drivers/gpu/drm/exynos/exynos_drm_drv.h
drivers/gpu/drm/exynos/exynos_drm_g2d.c
drivers/gpu/drm/exynos/exynos_drm_g2d.h
include/drm/exynos_drm.h

drivers/gpu/drm/exynos/Kconfig

Diff comments View file @ d7f1642

 config DRM_EXYNOS
 	tristate "DRM Support for Samsung SoC EXYNOS Series"
 	depends on DRM && PLAT_SAMSUNG
 	select DRM_KMS_HELPER
 	select FB_CFB_FILLRECT
 	select FB_CFB_COPYAREA
 	select FB_CFB_IMAGEBLIT
 	select VT_HW_CONSOLE_BINDING if FRAMEBUFFER_CONSOLE
 	help
 	  Choose this option if you have a Samsung SoC EXYNOS chipset.
 	  If M is selected the module will be called exynosdrm.
 config DRM_EXYNOS_DMABUF
 	bool "EXYNOS DRM DMABUF"
 	depends on DRM_EXYNOS
 	help
 	  Choose this option if you want to use DMABUF feature for DRM.
 config DRM_EXYNOS_FIMD
 	bool "Exynos DRM FIMD"
 	depends on DRM_EXYNOS && !FB_S3C
 	help
 	  Choose this option if you want to use Exynos FIMD for DRM.
 config DRM_EXYNOS_HDMI
 	bool "Exynos DRM HDMI"
 	depends on DRM_EXYNOS && !VIDEO_SAMSUNG_S5P_TV
 	help
 	  Choose this option if you want to use Exynos HDMI for DRM.
 config DRM_EXYNOS_VIDI
 	bool "Exynos DRM Virtual Display"
 	depends on DRM_EXYNOS
 	help
 	  Choose this option if you want to use Exynos VIDI for DRM.
+config DRM_EXYNOS_G2D
+	bool "Exynos DRM G2D"
+	depends on DRM_EXYNOS
+	help
+	  Choose this option if you want to use Exynos G2D for DRM.

drivers/gpu/drm/exynos/Makefile

Diff comments View file @ d7f1642

 #
 # Makefile for the drm device driver.  This driver provides support for the
 # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
 ccflags-y := -Iinclude/drm -Idrivers/gpu/drm/exynos
 exynosdrm-y := exynos_drm_drv.o exynos_drm_encoder.o exynos_drm_connector.o \
 		exynos_drm_crtc.o exynos_drm_fbdev.o exynos_drm_fb.o \
 		exynos_drm_buf.o exynos_drm_gem.o exynos_drm_core.o \
 		exynos_drm_plane.o
 exynosdrm-$(CONFIG_DRM_EXYNOS_DMABUF) += exynos_drm_dmabuf.o
 exynosdrm-$(CONFIG_DRM_EXYNOS_FIMD)	+= exynos_drm_fimd.o
 exynosdrm-$(CONFIG_DRM_EXYNOS_HDMI)	+= exynos_hdmi.o exynos_mixer.o \
 					   exynos_ddc.o exynos_hdmiphy.o \
 					   exynos_drm_hdmi.o
 exynosdrm-$(CONFIG_DRM_EXYNOS_VIDI)	+= exynos_drm_vidi.o
+exynosdrm-$(CONFIG_DRM_EXYNOS_G2D)	+= exynos_drm_g2d.o
 obj-$(CONFIG_DRM_EXYNOS)		+= exynosdrm.o

drivers/gpu/drm/exynos/exynos_drm_drv.c

Diff comments View file @ d7f1642

 /*
  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
  * Authors:
  *	Inki Dae <inki.dae@samsung.com>
  *	Joonyoung Shim <jy0922.shim@samsung.com>
  *	Seung-Woo Kim <sw0312.kim@samsung.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 #include "drmP.h"
 #include "drm.h"
 #include "drm_crtc_helper.h"
 #include <drm/exynos_drm.h>
 #include "exynos_drm_drv.h"
 #include "exynos_drm_crtc.h"
 #include "exynos_drm_encoder.h"
 #include "exynos_drm_fbdev.h"
 #include "exynos_drm_fb.h"
 #include "exynos_drm_gem.h"
 #include "exynos_drm_plane.h"
 #include "exynos_drm_vidi.h"
 #include "exynos_drm_dmabuf.h"
+#include "exynos_drm_g2d.h"
 #define DRIVER_NAME	"exynos"
 #define DRIVER_DESC	"Samsung SoC DRM"
 #define DRIVER_DATE	"20110530"
 #define DRIVER_MAJOR	1
 #define DRIVER_MINOR	0
 #define VBLANK_OFF_DELAY	50000
 static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
 {
 	struct exynos_drm_private *private;
 	int ret;
 	int nr;
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
 	if (!private) {
 		DRM_ERROR("failed to allocate private\n");
 		return -ENOMEM;
 	}
 	INIT_LIST_HEAD(&private->pageflip_event_list);
 	dev->dev_private = (void *)private;
 	drm_mode_config_init(dev);
 	/* init kms poll for handling hpd */
 	drm_kms_helper_poll_init(dev);
 	exynos_drm_mode_config_init(dev);
 	/*
 	 * EXYNOS4 is enough to have two CRTCs and each crtc would be used
 	 * without dependency of hardware.
 	 */
 	for (nr = 0; nr < MAX_CRTC; nr++) {
 		ret = exynos_drm_crtc_create(dev, nr);
 		if (ret)
 			goto err_crtc;
 	}
 	for (nr = 0; nr < MAX_PLANE; nr++) {
 		ret = exynos_plane_init(dev, nr);
 		if (ret)
 			goto err_crtc;
 	}
 	ret = drm_vblank_init(dev, MAX_CRTC);
 	if (ret)
 		goto err_crtc;
 	/*
 	 * probe sub drivers such as display controller and hdmi driver,
 	 * that were registered at probe() of platform driver
 	 * to the sub driver and create encoder and connector for them.
 	 */
 	ret = exynos_drm_device_register(dev);
 	if (ret)
 		goto err_vblank;
 	/* setup possible_clones. */
 	exynos_drm_encoder_setup(dev);
 	/*
 	 * create and configure fb helper and also exynos specific
 	 * fbdev object.
 	 */
 	ret = exynos_drm_fbdev_init(dev);
 	if (ret) {
 		DRM_ERROR("failed to initialize drm fbdev\n");
 		goto err_drm_device;
 	}
 	drm_vblank_offdelay = VBLANK_OFF_DELAY;
 	return 0;
 err_drm_device:
 	exynos_drm_device_unregister(dev);
 err_vblank:
 	drm_vblank_cleanup(dev);
 err_crtc:
 	drm_mode_config_cleanup(dev);
 	kfree(private);
 	return ret;
 }
 static int exynos_drm_unload(struct drm_device *dev)
 {
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	exynos_drm_fbdev_fini(dev);
 	exynos_drm_device_unregister(dev);
 	drm_vblank_cleanup(dev);
 	drm_kms_helper_poll_fini(dev);
 	drm_mode_config_cleanup(dev);
 	kfree(dev->dev_private);
 	dev->dev_private = NULL;
 	return 0;
 }
 static int exynos_drm_open(struct drm_device *dev, struct drm_file *file)
 {
+	struct drm_exynos_file_private *file_priv;
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
+	file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
+	if (!file_priv)
+		return -ENOMEM;
 	drm_prime_init_file_private(&file->prime);
+	file->driver_priv = file_priv;
 	return exynos_drm_subdrv_open(dev, file);
 }
 static void exynos_drm_preclose(struct drm_device *dev,
 					struct drm_file *file)
 {
 	struct exynos_drm_private *private = dev->dev_private;
 	struct drm_pending_vblank_event *e, *t;
 	unsigned long flags;
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	/* release events of current file */
 	spin_lock_irqsave(&dev->event_lock, flags);
 	list_for_each_entry_safe(e, t, &private->pageflip_event_list,
 			base.link) {
 		if (e->base.file_priv == file) {
 			list_del(&e->base.link);
 			e->base.destroy(&e->base);
 		}
 	}
 	drm_prime_destroy_file_private(&file->prime);
 	spin_unlock_irqrestore(&dev->event_lock, flags);
 	exynos_drm_subdrv_close(dev, file);
 }
 static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
 {
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	if (!file->driver_priv)
 		return;
 	kfree(file->driver_priv);
 	file->driver_priv = NULL;
 }
 static void exynos_drm_lastclose(struct drm_device *dev)
 {
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	exynos_drm_fbdev_restore_mode(dev);
 }
 static struct vm_operations_struct exynos_drm_gem_vm_ops = {
 	.fault = exynos_drm_gem_fault,
 	.open = drm_gem_vm_open,
 	.close = drm_gem_vm_close,
 };
 static struct drm_ioctl_desc exynos_ioctls[] = {
 	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
 			DRM_UNLOCKED | DRM_AUTH),
 	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP_OFFSET,
 			exynos_drm_gem_map_offset_ioctl, DRM_UNLOCKED |
 			DRM_AUTH),
 	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MMAP,
 			exynos_drm_gem_mmap_ioctl, DRM_UNLOCKED | DRM_AUTH),
 	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET,
 			exynos_drm_gem_get_ioctl, DRM_UNLOCKED),
 	DRM_IOCTL_DEF_DRV(EXYNOS_PLANE_SET_ZPOS, exynos_plane_set_zpos_ioctl,
 			DRM_UNLOCKED | DRM_AUTH),
 	DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION,
 			vidi_connection_ioctl, DRM_UNLOCKED | DRM_AUTH),
+	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER,
+			exynos_g2d_get_ver_ioctl, DRM_UNLOCKED | DRM_AUTH),
+	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST,
+			exynos_g2d_set_cmdlist_ioctl, DRM_UNLOCKED | DRM_AUTH),
+	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC,
+			exynos_g2d_exec_ioctl, DRM_UNLOCKED | DRM_AUTH),
 };
 static const struct file_operations exynos_drm_driver_fops = {
 	.owner		= THIS_MODULE,
 	.open		= drm_open,
 	.mmap		= exynos_drm_gem_mmap,
 	.poll		= drm_poll,
 	.read		= drm_read,
 	.unlocked_ioctl	= drm_ioctl,
 	.release	= drm_release,
 };
 static struct drm_driver exynos_drm_driver = {
 	.driver_features	= DRIVER_HAVE_IRQ | DRIVER_BUS_PLATFORM |
 				  DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
 	.load			= exynos_drm_load,
 	.unload			= exynos_drm_unload,
 	.open			= exynos_drm_open,
 	.preclose		= exynos_drm_preclose,
 	.lastclose		= exynos_drm_lastclose,
 	.postclose		= exynos_drm_postclose,
 	.get_vblank_counter	= drm_vblank_count,
 	.enable_vblank		= exynos_drm_crtc_enable_vblank,
 	.disable_vblank		= exynos_drm_crtc_disable_vblank,
 	.gem_init_object	= exynos_drm_gem_init_object,
 	.gem_free_object	= exynos_drm_gem_free_object,
 	.gem_vm_ops		= &exynos_drm_gem_vm_ops,
 	.dumb_create		= exynos_drm_gem_dumb_create,
 	.dumb_map_offset	= exynos_drm_gem_dumb_map_offset,
 	.dumb_destroy		= exynos_drm_gem_dumb_destroy,
 	.prime_handle_to_fd	= drm_gem_prime_handle_to_fd,
 	.prime_fd_to_handle	= drm_gem_prime_fd_to_handle,
 	.gem_prime_export	= exynos_dmabuf_prime_export,
 	.gem_prime_import	= exynos_dmabuf_prime_import,
 	.ioctls			= exynos_ioctls,
 	.fops			= &exynos_drm_driver_fops,
 	.name	= DRIVER_NAME,
 	.desc	= DRIVER_DESC,
 	.date	= DRIVER_DATE,
 	.major	= DRIVER_MAJOR,
 	.minor	= DRIVER_MINOR,
 };
 static int exynos_drm_platform_probe(struct platform_device *pdev)
 {
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	exynos_drm_driver.num_ioctls = DRM_ARRAY_SIZE(exynos_ioctls);
 	return drm_platform_init(&exynos_drm_driver, pdev);
 }
 static int exynos_drm_platform_remove(struct platform_device *pdev)
 {
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	drm_platform_exit(&exynos_drm_driver, pdev);
 	return 0;
 }
 static struct platform_driver exynos_drm_platform_driver = {
 	.probe		= exynos_drm_platform_probe,
 	.remove		= __devexit_p(exynos_drm_platform_remove),
 	.driver		= {
 		.owner	= THIS_MODULE,
 		.name	= "exynos-drm",
 	},
 };
 static int __init exynos_drm_init(void)
 {
 	int ret;
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 #ifdef CONFIG_DRM_EXYNOS_FIMD
 	ret = platform_driver_register(&fimd_driver);
 	if (ret < 0)
 		goto out_fimd;
 #endif
 #ifdef CONFIG_DRM_EXYNOS_HDMI
 	ret = platform_driver_register(&hdmi_driver);
 	if (ret < 0)
 		goto out_hdmi;
 	ret = platform_driver_register(&mixer_driver);
 	if (ret < 0)
 		goto out_mixer;
 	ret = platform_driver_register(&exynos_drm_common_hdmi_driver);
 	if (ret < 0)
 		goto out_common_hdmi;
 #endif
 #ifdef CONFIG_DRM_EXYNOS_VIDI
 	ret = platform_driver_register(&vidi_driver);
 	if (ret < 0)
 		goto out_vidi;
 #endif
+#ifdef CONFIG_DRM_EXYNOS_G2D
+	ret = platform_driver_register(&g2d_driver);
+	if (ret < 0)
+		goto out_g2d;
+#endif
 	ret = platform_driver_register(&exynos_drm_platform_driver);
 	if (ret < 0)
 		goto out;
 	return 0;
 out:
+#ifdef CONFIG_DRM_EXYNOS_G2D
+	platform_driver_unregister(&g2d_driver);
+out_g2d:
+#endif
 #ifdef CONFIG_DRM_EXYNOS_VIDI
 out_vidi:
 	platform_driver_unregister(&vidi_driver);
 #endif
 #ifdef CONFIG_DRM_EXYNOS_HDMI
 	platform_driver_unregister(&exynos_drm_common_hdmi_driver);
 out_common_hdmi:
 	platform_driver_unregister(&mixer_driver);
 out_mixer:
 	platform_driver_unregister(&hdmi_driver);
 out_hdmi:
 #endif
 #ifdef CONFIG_DRM_EXYNOS_FIMD
 	platform_driver_unregister(&fimd_driver);
 out_fimd:
 #endif
 	return ret;
 }
 static void __exit exynos_drm_exit(void)
 {
 	DRM_DEBUG_DRIVER("%s\n", __FILE__);
 	platform_driver_unregister(&exynos_drm_platform_driver);
+#ifdef CONFIG_DRM_EXYNOS_G2D
+	platform_driver_unregister(&g2d_driver);
+#endif
 #ifdef CONFIG_DRM_EXYNOS_HDMI
 	platform_driver_unregister(&exynos_drm_common_hdmi_driver);
 	platform_driver_unregister(&mixer_driver);
 	platform_driver_unregister(&hdmi_driver);
 #endif
 #ifdef CONFIG_DRM_EXYNOS_VIDI
 	platform_driver_unregister(&vidi_driver);
 #endif
 #ifdef CONFIG_DRM_EXYNOS_FIMD
 	platform_driver_unregister(&fimd_driver);
 #endif
 }
 module_init(exynos_drm_init);
 module_exit(exynos_drm_exit);
 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
 MODULE_DESCRIPTION("Samsung SoC DRM Driver");
 MODULE_LICENSE("GPL");

drivers/gpu/drm/exynos/exynos_drm_drv.h

Diff comments View file @ d7f1642

 /* exynos_drm_drv.h
  *
  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
  * Authors:
  *	Inki Dae <inki.dae@samsung.com>
  *	Joonyoung Shim <jy0922.shim@samsung.com>
  *	Seung-Woo Kim <sw0312.kim@samsung.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 #ifndef _EXYNOS_DRM_DRV_H_
 #define _EXYNOS_DRM_DRV_H_
 #include <linux/module.h>
 #include "drm.h"
 #define MAX_CRTC	3
 #define MAX_PLANE	5
 #define MAX_FB_BUFFER	4
 #define DEFAULT_ZPOS	-1
 struct drm_device;
 struct exynos_drm_overlay;
 struct drm_connector;
 extern unsigned int drm_vblank_offdelay;
 /* this enumerates display type. */
 enum exynos_drm_output_type {
 	EXYNOS_DISPLAY_TYPE_NONE,
 	/* RGB or CPU Interface. */
 	EXYNOS_DISPLAY_TYPE_LCD,
 	/* HDMI Interface. */
 	EXYNOS_DISPLAY_TYPE_HDMI,
 	/* Virtual Display Interface. */
 	EXYNOS_DISPLAY_TYPE_VIDI,
 };
 /*
  * Exynos drm overlay ops structure.
  *
  * @mode_set: copy drm overlay info to hw specific overlay info.
  * @commit: apply hardware specific overlay data to registers.
  * @disable: disable hardware specific overlay.
  */
 struct exynos_drm_overlay_ops {
 	void (*mode_set)(struct device *subdrv_dev,
 			 struct exynos_drm_overlay *overlay);
 	void (*commit)(struct device *subdrv_dev, int zpos);
 	void (*disable)(struct device *subdrv_dev, int zpos);
 };
 /*
  * Exynos drm common overlay structure.
  *
  * @fb_x: offset x on a framebuffer to be displayed.
  *	- the unit is screen coordinates.
  * @fb_y: offset y on a framebuffer to be displayed.
  *	- the unit is screen coordinates.
  * @fb_width: width of a framebuffer.
  * @fb_height: height of a framebuffer.
  * @src_width: width of a partial image to be displayed from framebuffer.
  * @src_height: height of a partial image to be displayed from framebuffer.
  * @crtc_x: offset x on hardware screen.
  * @crtc_y: offset y on hardware screen.
  * @crtc_width: window width to be displayed (hardware screen).
  * @crtc_height: window height to be displayed (hardware screen).
  * @mode_width: width of screen mode.
  * @mode_height: height of screen mode.
  * @refresh: refresh rate.
  * @scan_flag: interlace or progressive way.
  *	(it could be DRM_MODE_FLAG_*)
  * @bpp: pixel size.(in bit)
  * @pixel_format: fourcc pixel format of this overlay
  * @dma_addr: array of bus(accessed by dma) address to the memory region
  *	      allocated for a overlay.
  * @vaddr: array of virtual memory addresss to this overlay.
  * @zpos: order of overlay layer(z position).
  * @default_win: a window to be enabled.
  * @color_key: color key on or off.
  * @index_color: if using color key feature then this value would be used
  *			as index color.
  * @local_path: in case of lcd type, local path mode on or off.
  * @transparency: transparency on or off.
  * @activated: activated or not.
  *
  * this structure is common to exynos SoC and its contents would be copied
  * to hardware specific overlay info.
  */
 struct exynos_drm_overlay {
 	unsigned int fb_x;
 	unsigned int fb_y;
 	unsigned int fb_width;
 	unsigned int fb_height;
 	unsigned int src_width;
 	unsigned int src_height;
 	unsigned int crtc_x;
 	unsigned int crtc_y;
 	unsigned int crtc_width;
 	unsigned int crtc_height;
 	unsigned int mode_width;
 	unsigned int mode_height;
 	unsigned int refresh;
 	unsigned int scan_flag;
 	unsigned int bpp;
 	unsigned int pitch;
 	uint32_t pixel_format;
 	dma_addr_t dma_addr[MAX_FB_BUFFER];
 	void __iomem *vaddr[MAX_FB_BUFFER];
 	int zpos;
 	bool default_win;
 	bool color_key;
 	unsigned int index_color;
 	bool local_path;
 	bool transparency;
 	bool activated;
 };
 /*
  * Exynos DRM Display Structure.
  *	- this structure is common to analog tv, digital tv and lcd panel.
  *
  * @type: one of EXYNOS_DISPLAY_TYPE_LCD and HDMI.
  * @is_connected: check for that display is connected or not.
  * @get_edid: get edid modes from display driver.
  * @get_panel: get panel object from display driver.
  * @check_timing: check if timing is valid or not.
  * @power_on: display device on or off.
  */
 struct exynos_drm_display_ops {
 	enum exynos_drm_output_type type;
 	bool (*is_connected)(struct device *dev);
 	int (*get_edid)(struct device *dev, struct drm_connector *connector,
 				u8 *edid, int len);
 	void *(*get_panel)(struct device *dev);
 	int (*check_timing)(struct device *dev, void *timing);
 	int (*power_on)(struct device *dev, int mode);
 };
 /*
  * Exynos drm manager ops
  *
  * @dpms: control device power.
  * @apply: set timing, vblank and overlay data to registers.
  * @mode_fixup: fix mode data comparing to hw specific display mode.
  * @mode_set: convert drm_display_mode to hw specific display mode and
  *	      would be called by encoder->mode_set().
  * @get_max_resol: get maximum resolution to specific hardware.
  * @commit: set current hw specific display mode to hw.
  * @enable_vblank: specific driver callback for enabling vblank interrupt.
  * @disable_vblank: specific driver callback for disabling vblank interrupt.
  */
 struct exynos_drm_manager_ops {
 	void (*dpms)(struct device *subdrv_dev, int mode);
 	void (*apply)(struct device *subdrv_dev);
 	void (*mode_fixup)(struct device *subdrv_dev,
 				struct drm_connector *connector,
 				struct drm_display_mode *mode,
 				struct drm_display_mode *adjusted_mode);
 	void (*mode_set)(struct device *subdrv_dev, void *mode);
 	void (*get_max_resol)(struct device *subdrv_dev, unsigned int *width,
 				unsigned int *height);
 	void (*commit)(struct device *subdrv_dev);
 	int (*enable_vblank)(struct device *subdrv_dev);
 	void (*disable_vblank)(struct device *subdrv_dev);
 };
 /*
  * Exynos drm common manager structure.
  *
  * @dev: pointer to device object for subdrv device driver.
  *	sub drivers such as display controller or hdmi driver,
  *	have their own device object.
  * @ops: pointer to callbacks for exynos drm specific framebuffer.
  *	these callbacks should be set by specific drivers such fimd
  *	or hdmi driver and are used to control hardware global registers.
  * @overlay_ops: pointer to callbacks for exynos drm specific framebuffer.
  *	these callbacks should be set by specific drivers such fimd
  *	or hdmi driver and are used to control hardware overlay reigsters.
  * @display: pointer to callbacks for exynos drm specific framebuffer.
  *	these callbacks should be set by specific drivers such fimd
  *	or hdmi driver and are used to control display devices such as
  *	analog tv, digital tv and lcd panel and also get timing data for them.
  */
 struct exynos_drm_manager {
 	struct device *dev;
 	int pipe;
 	struct exynos_drm_manager_ops *ops;
 	struct exynos_drm_overlay_ops *overlay_ops;
 	struct exynos_drm_display_ops *display_ops;
 };
+struct exynos_drm_g2d_private {
+	struct device		*dev;
+	struct list_head	inuse_cmdlist;
+	struct list_head	event_list;
+	struct list_head	gem_list;
+	unsigned int		gem_nr;
+};
+struct drm_exynos_file_private {
+	struct exynos_drm_g2d_private	*g2d_priv;
+};
 /*
  * Exynos drm private structure.
  */
 struct exynos_drm_private {
 	struct drm_fb_helper *fb_helper;
 	/* list head for new event to be added. */
 	struct list_head pageflip_event_list;
 	/*
 	 * created crtc object would be contained at this array and
 	 * this array is used to be aware of which crtc did it request vblank.
 	 */
 	struct drm_crtc *crtc[MAX_CRTC];
 };
 /*
  * Exynos drm sub driver structure.
  *
  * @list: sub driver has its own list object to register to exynos drm driver.
  * @dev: pointer to device object for subdrv device driver.
  * @drm_dev: pointer to drm_device and this pointer would be set
  *	when sub driver calls exynos_drm_subdrv_register().
  * @manager: subdrv has its own manager to control a hardware appropriately
  *	and we can access a hardware drawing on this manager.
  * @probe: this callback would be called by exynos drm driver after
  *	subdrv is registered to it.
  * @remove: this callback is used to release resources created
  *	by probe callback.
  * @open: this would be called with drm device file open.
  * @close: this would be called with drm device file close.
  * @encoder: encoder object owned by this sub driver.
  * @connector: connector object owned by this sub driver.
  */
 struct exynos_drm_subdrv {
 	struct list_head list;
 	struct device *dev;
 	struct drm_device *drm_dev;
 	struct exynos_drm_manager *manager;
 	int (*probe)(struct drm_device *drm_dev, struct device *dev);
 	void (*remove)(struct drm_device *dev);
 	int (*open)(struct drm_device *drm_dev, struct device *dev,
 			struct drm_file *file);
 	void (*close)(struct drm_device *drm_dev, struct device *dev,
 			struct drm_file *file);
 	struct drm_encoder *encoder;
 	struct drm_connector *connector;
 };
 /*
  * this function calls a probe callback registered to sub driver list and
  * create its own encoder and connector and then set drm_device object
  * to global one.
  */
 int exynos_drm_device_register(struct drm_device *dev);
 /*
  * this function calls a remove callback registered to sub driver list and
  * destroy its own encoder and connetor.
  */
 int exynos_drm_device_unregister(struct drm_device *dev);
 /*
  * this function would be called by sub drivers such as display controller
  * or hdmi driver to register this sub driver object to exynos drm driver
  * and when a sub driver is registered to exynos drm driver a probe callback
  * of the sub driver is called and creates its own encoder and connector.
  */
 int exynos_drm_subdrv_register(struct exynos_drm_subdrv *drm_subdrv);
 /* this function removes subdrv list from exynos drm driver */
 int exynos_drm_subdrv_unregister(struct exynos_drm_subdrv *drm_subdrv);
 int exynos_drm_subdrv_open(struct drm_device *dev, struct drm_file *file);
 void exynos_drm_subdrv_close(struct drm_device *dev, struct drm_file *file);
 extern struct platform_driver fimd_driver;
 extern struct platform_driver hdmi_driver;
 extern struct platform_driver mixer_driver;
 extern struct platform_driver exynos_drm_common_hdmi_driver;
 extern struct platform_driver vidi_driver;
+extern struct platform_driver g2d_driver;
 #endif

drivers/gpu/drm/exynos/exynos_drm_g2d.c

Diff comments View file @ d7f1642

File was created	1	/*
	2	* Copyright (C) 2012 Samsung Electronics Co.Ltd
	3	* Authors: Joonyoung Shim <jy0922.shim@samsung.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundationr
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <linux/clk.h>
	13	#include <linux/err.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/io.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/pm_runtime.h>
	18	#include <linux/slab.h>
	19	#include <linux/workqueue.h>
	20
	21	#include "drmP.h"
	22	#include "exynos_drm.h"
	23	#include "exynos_drm_drv.h"
	24	#include "exynos_drm_gem.h"
	25
	26	#define G2D_HW_MAJOR_VER 4
	27	#define G2D_HW_MINOR_VER 1
	28
	29	/* vaild register range set from user: 0x0104 ~ 0x0880 */
	30	#define G2D_VALID_START 0x0104
	31	#define G2D_VALID_END 0x0880
	32
	33	/* general registers */
	34	#define G2D_SOFT_RESET 0x0000
	35	#define G2D_INTEN 0x0004
	36	#define G2D_INTC_PEND 0x000C
	37	#define G2D_DMA_SFR_BASE_ADDR 0x0080
	38	#define G2D_DMA_COMMAND 0x0084
	39	#define G2D_DMA_STATUS 0x008C
	40	#define G2D_DMA_HOLD_CMD 0x0090
	41
	42	/* command registers */
	43	#define G2D_BITBLT_START 0x0100
	44
	45	/* registers for base address */
	46	#define G2D_SRC_BASE_ADDR 0x0304
	47	#define G2D_SRC_PLANE2_BASE_ADDR 0x0318
	48	#define G2D_DST_BASE_ADDR 0x0404
	49	#define G2D_DST_PLANE2_BASE_ADDR 0x0418
	50	#define G2D_PAT_BASE_ADDR 0x0500
	51	#define G2D_MSK_BASE_ADDR 0x0520
	52
	53	/* G2D_SOFT_RESET */
	54	#define G2D_SFRCLEAR (1 << 1)
	55	#define G2D_R (1 << 0)
	56
	57	/* G2D_INTEN */
	58	#define G2D_INTEN_ACF (1 << 3)
	59	#define G2D_INTEN_UCF (1 << 2)
	60	#define G2D_INTEN_GCF (1 << 1)
	61	#define G2D_INTEN_SCF (1 << 0)
	62
	63	/* G2D_INTC_PEND */
	64	#define G2D_INTP_ACMD_FIN (1 << 3)
	65	#define G2D_INTP_UCMD_FIN (1 << 2)
	66	#define G2D_INTP_GCMD_FIN (1 << 1)
	67	#define G2D_INTP_SCMD_FIN (1 << 0)
	68
	69	/* G2D_DMA_COMMAND */
	70	#define G2D_DMA_HALT (1 << 2)
	71	#define G2D_DMA_CONTINUE (1 << 1)
	72	#define G2D_DMA_START (1 << 0)
	73
	74	/* G2D_DMA_STATUS */
	75	#define G2D_DMA_LIST_DONE_COUNT (0xFF << 17)
	76	#define G2D_DMA_BITBLT_DONE_COUNT (0xFFFF << 1)
	77	#define G2D_DMA_DONE (1 << 0)
	78	#define G2D_DMA_LIST_DONE_COUNT_OFFSET 17
	79
	80	/* G2D_DMA_HOLD_CMD */
	81	#define G2D_USET_HOLD (1 << 2)
	82	#define G2D_LIST_HOLD (1 << 1)
	83	#define G2D_BITBLT_HOLD (1 << 0)
	84
	85	/* G2D_BITBLT_START */
	86	#define G2D_START_CASESEL (1 << 2)
	87	#define G2D_START_NHOLT (1 << 1)
	88	#define G2D_START_BITBLT (1 << 0)
	89
	90	#define G2D_CMDLIST_SIZE (PAGE_SIZE / 4)
	91	#define G2D_CMDLIST_NUM 64
	92	#define G2D_CMDLIST_POOL_SIZE (G2D_CMDLIST_SIZE * G2D_CMDLIST_NUM)
	93	#define G2D_CMDLIST_DATA_NUM (G2D_CMDLIST_SIZE / sizeof(u32) - 2)
	94
	95	/* cmdlist data structure */
	96	struct g2d_cmdlist {
	97	u32 head;
	98	u32 data[G2D_CMDLIST_DATA_NUM];
	99	u32 last; /* last data offset */
	100	};
	101
	102	struct drm_exynos_pending_g2d_event {
	103	struct drm_pending_event base;
	104	struct drm_exynos_g2d_event event;
	105	};
	106
	107	struct g2d_gem_node {
	108	struct list_head list;
	109	unsigned int handle;
	110	};
	111
	112	struct g2d_cmdlist_node {
	113	struct list_head list;
	114	struct g2d_cmdlist *cmdlist;
	115	unsigned int gem_nr;
	116	dma_addr_t dma_addr;
	117
	118	struct drm_exynos_pending_g2d_event *event;
	119	};
	120
	121	struct g2d_runqueue_node {
	122	struct list_head list;
	123	struct list_head run_cmdlist;
	124	struct list_head event_list;
	125	struct completion complete;
	126	int async;
	127	};
	128
	129	struct g2d_data {
	130	struct device *dev;
	131	struct clk *gate_clk;
	132	struct resource *regs_res;
	133	void __iomem *regs;
	134	int irq;
	135	struct workqueue_struct *g2d_workq;
	136	struct work_struct runqueue_work;
	137	struct exynos_drm_subdrv subdrv;
	138	bool suspended;
	139
	140	/* cmdlist */
	141	struct g2d_cmdlist_node *cmdlist_node;
	142	struct list_head free_cmdlist;
	143	struct mutex cmdlist_mutex;
	144	dma_addr_t cmdlist_pool;
	145	void *cmdlist_pool_virt;
	146
	147	/* runqueue*/
	148	struct g2d_runqueue_node *runqueue_node;
	149	struct list_head runqueue;
	150	struct mutex runqueue_mutex;
	151	struct kmem_cache *runqueue_slab;
	152	};
	153
	154	static int g2d_init_cmdlist(struct g2d_data *g2d)
	155	{
	156	struct device *dev = g2d->dev;
	157	struct g2d_cmdlist_node *node = g2d->cmdlist_node;
	158	int nr;
	159	int ret;
	160
	161	g2d->cmdlist_pool_virt = dma_alloc_coherent(dev, G2D_CMDLIST_POOL_SIZE,
	162	&g2d->cmdlist_pool, GFP_KERNEL);
	163	if (!g2d->cmdlist_pool_virt) {
	164	dev_err(dev, "failed to allocate dma memory\n");
	165	return -ENOMEM;
	166	}
	167
	168	node = kcalloc(G2D_CMDLIST_NUM, G2D_CMDLIST_NUM * sizeof(*node),
	169	GFP_KERNEL);
	170	if (!node) {
	171	dev_err(dev, "failed to allocate memory\n");
	172	ret = -ENOMEM;
	173	goto err;
	174	}
	175
	176	for (nr = 0; nr < G2D_CMDLIST_NUM; nr++) {
	177	node[nr].cmdlist =
	178	g2d->cmdlist_pool_virt + nr * G2D_CMDLIST_SIZE;
	179	node[nr].dma_addr =
	180	g2d->cmdlist_pool + nr * G2D_CMDLIST_SIZE;
	181
	182	list_add_tail(&node[nr].list, &g2d->free_cmdlist);
	183	}
	184
	185	return 0;
	186
	187	err:
	188	dma_free_coherent(dev, G2D_CMDLIST_POOL_SIZE, g2d->cmdlist_pool_virt,
	189	g2d->cmdlist_pool);
	190	return ret;
	191	}
	192
	193	static void g2d_fini_cmdlist(struct g2d_data *g2d)
	194	{
	195	struct device *dev = g2d->dev;
	196
	197	kfree(g2d->cmdlist_node);
	198	dma_free_coherent(dev, G2D_CMDLIST_POOL_SIZE, g2d->cmdlist_pool_virt,
	199	g2d->cmdlist_pool);
	200	}
	201
	202	static struct g2d_cmdlist_node g2d_get_cmdlist(struct g2d_data g2d)
	203	{
	204	struct device *dev = g2d->dev;
	205	struct g2d_cmdlist_node *node;
	206
	207	mutex_lock(&g2d->cmdlist_mutex);
	208	if (list_empty(&g2d->free_cmdlist)) {
	209	dev_err(dev, "there is no free cmdlist\n");
	210	mutex_unlock(&g2d->cmdlist_mutex);
	211	return NULL;
	212	}
	213
	214	node = list_first_entry(&g2d->free_cmdlist, struct g2d_cmdlist_node,
	215	list);
	216	list_del_init(&node->list);
	217	mutex_unlock(&g2d->cmdlist_mutex);
	218
	219	return node;
	220	}
	221
	222	static void g2d_put_cmdlist(struct g2d_data g2d, struct g2d_cmdlist_node node)
	223	{
	224	mutex_lock(&g2d->cmdlist_mutex);
	225	list_move_tail(&node->list, &g2d->free_cmdlist);
	226	mutex_unlock(&g2d->cmdlist_mutex);
	227	}
	228
	229	static void g2d_add_cmdlist_to_inuse(struct exynos_drm_g2d_private *g2d_priv,
	230	struct g2d_cmdlist_node *node)
	231	{
	232	struct g2d_cmdlist_node *lnode;
	233
	234	if (list_empty(&g2d_priv->inuse_cmdlist))
	235	goto add_to_list;
	236
	237	/* this links to base address of new cmdlist */
	238	lnode = list_entry(g2d_priv->inuse_cmdlist.prev,
	239	struct g2d_cmdlist_node, list);
	240	lnode->cmdlist->data[lnode->cmdlist->last] = node->dma_addr;
	241
	242	add_to_list:
	243	list_add_tail(&node->list, &g2d_priv->inuse_cmdlist);
	244
	245	if (node->event)
	246	list_add_tail(&node->event->base.link, &g2d_priv->event_list);
	247	}
	248
	249	static int g2d_get_cmdlist_gem(struct drm_device *drm_dev,
	250	struct drm_file *file,
	251	struct g2d_cmdlist_node *node)
	252	{
	253	struct drm_exynos_file_private *file_priv = file->driver_priv;
	254	struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
	255	struct g2d_cmdlist *cmdlist = node->cmdlist;
	256	dma_addr_t *addr;
	257	int offset;
	258	int i;
	259
	260	for (i = 0; i < node->gem_nr; i++) {
	261	struct g2d_gem_node *gem_node;
	262
	263	gem_node = kzalloc(sizeof(*gem_node), GFP_KERNEL);
	264	if (!gem_node) {
	265	dev_err(g2d_priv->dev, "failed to allocate gem node\n");
	266	return -ENOMEM;
	267	}
	268
	269	offset = cmdlist->last - (i * 2 + 1);
	270	gem_node->handle = cmdlist->data[offset];
	271
	272	addr = exynos_drm_gem_get_dma_addr(drm_dev, gem_node->handle,
	273	file);
	274	if (IS_ERR(addr)) {
	275	node->gem_nr = i;
	276	kfree(gem_node);
	277	return PTR_ERR(addr);
	278	}
	279
	280	cmdlist->data[offset] = *addr;
	281	list_add_tail(&gem_node->list, &g2d_priv->gem_list);
	282	g2d_priv->gem_nr++;
	283	}
	284
	285	return 0;
	286	}
	287
	288	static void g2d_put_cmdlist_gem(struct drm_device *drm_dev,
	289	struct drm_file *file,
	290	unsigned int nr)
	291	{
	292	struct drm_exynos_file_private *file_priv = file->driver_priv;
	293	struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
	294	struct g2d_gem_node node, n;
	295
	296	list_for_each_entry_safe_reverse(node, n, &g2d_priv->gem_list, list) {
	297	if (!nr)
	298	break;
	299
	300	exynos_drm_gem_put_dma_addr(drm_dev, node->handle, file);
	301	list_del_init(&node->list);
	302	kfree(node);
	303	nr--;
	304	}
	305	}
	306
	307	static void g2d_dma_start(struct g2d_data *g2d,
	308	struct g2d_runqueue_node *runqueue_node)
	309	{
	310	struct g2d_cmdlist_node *node =
	311	list_first_entry(&runqueue_node->run_cmdlist,
	312	struct g2d_cmdlist_node, list);
	313
	314	pm_runtime_get_sync(g2d->dev);
	315	clk_enable(g2d->gate_clk);
	316
	317	/* interrupt enable */
	318	writel_relaxed(G2D_INTEN_ACF \| G2D_INTEN_UCF \| G2D_INTEN_GCF,
	319	g2d->regs + G2D_INTEN);
	320
	321	writel_relaxed(node->dma_addr, g2d->regs + G2D_DMA_SFR_BASE_ADDR);
	322	writel_relaxed(G2D_DMA_START, g2d->regs + G2D_DMA_COMMAND);
	323	}
	324
	325	static struct g2d_runqueue_node g2d_get_runqueue_node(struct g2d_data g2d)
	326	{
	327	struct g2d_runqueue_node *runqueue_node;
	328
	329	if (list_empty(&g2d->runqueue))
	330	return NULL;
	331
	332	runqueue_node = list_first_entry(&g2d->runqueue,
	333	struct g2d_runqueue_node, list);
	334	list_del_init(&runqueue_node->list);
	335	return runqueue_node;
	336	}
	337
	338	static void g2d_free_runqueue_node(struct g2d_data *g2d,
	339	struct g2d_runqueue_node *runqueue_node)
	340	{
	341	if (!runqueue_node)
	342	return;
	343
	344	mutex_lock(&g2d->cmdlist_mutex);
	345	list_splice_tail_init(&runqueue_node->run_cmdlist, &g2d->free_cmdlist);
	346	mutex_unlock(&g2d->cmdlist_mutex);
	347
	348	kmem_cache_free(g2d->runqueue_slab, runqueue_node);
	349	}
	350
	351	static void g2d_exec_runqueue(struct g2d_data *g2d)
	352	{
	353	g2d->runqueue_node = g2d_get_runqueue_node(g2d);
	354	if (g2d->runqueue_node)
	355	g2d_dma_start(g2d, g2d->runqueue_node);
	356	}
	357
	358	static void g2d_runqueue_worker(struct work_struct *work)
	359	{
	360	struct g2d_data *g2d = container_of(work, struct g2d_data,
	361	runqueue_work);
	362
	363
	364	mutex_lock(&g2d->runqueue_mutex);
	365	clk_disable(g2d->gate_clk);
	366	pm_runtime_put_sync(g2d->dev);
	367
	368	complete(&g2d->runqueue_node->complete);
	369	if (g2d->runqueue_node->async)
	370	g2d_free_runqueue_node(g2d, g2d->runqueue_node);
	371
	372	if (g2d->suspended)
	373	g2d->runqueue_node = NULL;
	374	else
	375	g2d_exec_runqueue(g2d);
	376	mutex_unlock(&g2d->runqueue_mutex);
	377	}
	378
	379	static void g2d_finish_event(struct g2d_data *g2d, u32 cmdlist_no)
	380	{
	381	struct drm_device *drm_dev = g2d->subdrv.drm_dev;
	382	struct g2d_runqueue_node *runqueue_node = g2d->runqueue_node;
	383	struct drm_exynos_pending_g2d_event *e;
	384	struct timeval now;
	385	unsigned long flags;
	386
	387	if (list_empty(&runqueue_node->event_list))
	388	return;
	389
	390	e = list_first_entry(&runqueue_node->event_list,
	391	struct drm_exynos_pending_g2d_event, base.link);
	392
	393	do_gettimeofday(&now);
	394	e->event.tv_sec = now.tv_sec;
	395	e->event.tv_usec = now.tv_usec;
	396	e->event.cmdlist_no = cmdlist_no;
	397
	398	spin_lock_irqsave(&drm_dev->event_lock, flags);
	399	list_move_tail(&e->base.link, &e->base.file_priv->event_list);
	400	wake_up_interruptible(&e->base.file_priv->event_wait);
	401	spin_unlock_irqrestore(&drm_dev->event_lock, flags);
	402	}
	403
	404	static irqreturn_t g2d_irq_handler(int irq, void *dev_id)
	405	{
	406	struct g2d_data *g2d = dev_id;
	407	u32 pending;
	408
	409	pending = readl_relaxed(g2d->regs + G2D_INTC_PEND);
	410	if (pending)
	411	writel_relaxed(pending, g2d->regs + G2D_INTC_PEND);
	412
	413	if (pending & G2D_INTP_GCMD_FIN) {
	414	u32 cmdlist_no = readl_relaxed(g2d->regs + G2D_DMA_STATUS);
	415
	416	cmdlist_no = (cmdlist_no & G2D_DMA_LIST_DONE_COUNT) >>
	417	G2D_DMA_LIST_DONE_COUNT_OFFSET;
	418
	419	g2d_finish_event(g2d, cmdlist_no);
	420
	421	writel_relaxed(0, g2d->regs + G2D_DMA_HOLD_CMD);
	422	if (!(pending & G2D_INTP_ACMD_FIN)) {
	423	writel_relaxed(G2D_DMA_CONTINUE,
	424	g2d->regs + G2D_DMA_COMMAND);
	425	}
	426	}
	427
	428	if (pending & G2D_INTP_ACMD_FIN)
	429	queue_work(g2d->g2d_workq, &g2d->runqueue_work);
	430
	431	return IRQ_HANDLED;
	432	}
	433
	434	static int g2d_check_reg_offset(struct device dev, struct g2d_cmdlist cmdlist,
	435	int nr, bool for_addr)
	436	{
	437	int reg_offset;
	438	int index;
	439	int i;
	440
	441	for (i = 0; i < nr; i++) {
	442	index = cmdlist->last - 2 * (i + 1);
	443	reg_offset = cmdlist->data[index] & ~0xfffff000;
	444
	445	if (reg_offset < G2D_VALID_START \|\| reg_offset > G2D_VALID_END)
	446	goto err;
	447	if (reg_offset % 4)
	448	goto err;
	449
	450	switch (reg_offset) {
	451	case G2D_SRC_BASE_ADDR:
	452	case G2D_SRC_PLANE2_BASE_ADDR:
	453	case G2D_DST_BASE_ADDR:
	454	case G2D_DST_PLANE2_BASE_ADDR:
	455	case G2D_PAT_BASE_ADDR:
	456	case G2D_MSK_BASE_ADDR:
	457	if (!for_addr)
	458	goto err;
	459	break;
	460	default:
	461	if (for_addr)
	462	goto err;
	463	break;
	464	}
	465	}
	466
	467	return 0;
	468
	469	err:
	470	dev_err(dev, "Bad register offset: 0x%x\n", cmdlist->data[index]);
	471	return -EINVAL;
	472	}
	473
	474	/* ioctl functions */
	475	int exynos_g2d_get_ver_ioctl(struct drm_device drm_dev, void data,
	476	struct drm_file *file)
	477	{
	478	struct drm_exynos_g2d_get_ver *ver = data;
	479
	480	ver->major = G2D_HW_MAJOR_VER;
	481	ver->minor = G2D_HW_MINOR_VER;
	482
	483	return 0;
	484	}
	485	EXPORT_SYMBOL_GPL(exynos_g2d_get_ver_ioctl);
	486
	487	int exynos_g2d_set_cmdlist_ioctl(struct drm_device drm_dev, void data,
	488	struct drm_file *file)
	489	{
	490	struct drm_exynos_file_private *file_priv = file->driver_priv;
	491	struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
	492	struct device *dev = g2d_priv->dev;
	493	struct g2d_data *g2d;
	494	struct drm_exynos_g2d_set_cmdlist *req = data;
	495	struct drm_exynos_g2d_cmd *cmd;
	496	struct drm_exynos_pending_g2d_event *e;
	497	struct g2d_cmdlist_node *node;
	498	struct g2d_cmdlist *cmdlist;
	499	unsigned long flags;
	500	int size;
	501	int ret;
	502
	503	if (!dev)
	504	return -ENODEV;
	505
	506	g2d = dev_get_drvdata(dev);
	507	if (!g2d)
	508	return -EFAULT;
	509
	510	node = g2d_get_cmdlist(g2d);
	511	if (!node)
	512	return -ENOMEM;
	513
	514	node->event = NULL;
	515
	516	if (req->event_type != G2D_EVENT_NOT) {
	517	spin_lock_irqsave(&drm_dev->event_lock, flags);
	518	if (file->event_space < sizeof(e->event)) {
	519	spin_unlock_irqrestore(&drm_dev->event_lock, flags);
	520	ret = -ENOMEM;
	521	goto err;
	522	}
	523	file->event_space -= sizeof(e->event);
	524	spin_unlock_irqrestore(&drm_dev->event_lock, flags);
	525
	526	e = kzalloc(sizeof(*node->event), GFP_KERNEL);
	527	if (!e) {
	528	dev_err(dev, "failed to allocate event\n");
	529
	530	spin_lock_irqsave(&drm_dev->event_lock, flags);
	531	file->event_space += sizeof(e->event);
	532	spin_unlock_irqrestore(&drm_dev->event_lock, flags);
	533
	534	ret = -ENOMEM;
	535	goto err;
	536	}
	537
	538	e->event.base.type = DRM_EXYNOS_G2D_EVENT;
	539	e->event.base.length = sizeof(e->event);
	540	e->event.user_data = req->user_data;
	541	e->base.event = &e->event.base;
	542	e->base.file_priv = file;
	543	e->base.destroy = (void () (struct drm_pending_event )) kfree;
	544
	545	node->event = e;
	546	}
	547
	548	cmdlist = node->cmdlist;
	549
	550	cmdlist->last = 0;
	551
	552	/*
	553	* If don't clear SFR registers, the cmdlist is affected by register
	554	* values of previous cmdlist. G2D hw executes SFR clear command and
	555	* a next command at the same time then the next command is ignored and
	556	* is executed rightly from next next command, so needs a dummy command
	557	* to next command of SFR clear command.
	558	*/
	559	cmdlist->data[cmdlist->last++] = G2D_SOFT_RESET;
	560	cmdlist->data[cmdlist->last++] = G2D_SFRCLEAR;
	561	cmdlist->data[cmdlist->last++] = G2D_SRC_BASE_ADDR;
	562	cmdlist->data[cmdlist->last++] = 0;
	563
	564	if (node->event) {
	565	cmdlist->data[cmdlist->last++] = G2D_DMA_HOLD_CMD;
	566	cmdlist->data[cmdlist->last++] = G2D_LIST_HOLD;
	567	}
	568
	569	/* Check size of cmdlist: last 2 is about G2D_BITBLT_START */
	570	size = cmdlist->last + req->cmd_nr * 2 + req->cmd_gem_nr * 2 + 2;
	571	if (size > G2D_CMDLIST_DATA_NUM) {
	572	dev_err(dev, "cmdlist size is too big\n");
	573	ret = -EINVAL;
	574	goto err_free_event;
	575	}
	576
	577	cmd = (struct drm_exynos_g2d_cmd *)(uint32_t)req->cmd;
	578
	579	if (copy_from_user(cmdlist->data + cmdlist->last,
	580	(void __user *)cmd,
	581	sizeof(cmd) req->cmd_nr)) {
	582	ret = -EFAULT;
	583	goto err_free_event;
	584	}
	585	cmdlist->last += req->cmd_nr * 2;
	586
	587	ret = g2d_check_reg_offset(dev, cmdlist, req->cmd_nr, false);
	588	if (ret < 0)
	589	goto err_free_event;
	590
	591	node->gem_nr = req->cmd_gem_nr;
	592	if (req->cmd_gem_nr) {
	593	struct drm_exynos_g2d_cmd *cmd_gem;
	594
	595	cmd_gem = (struct drm_exynos_g2d_cmd *)(uint32_t)req->cmd_gem;
	596
	597	if (copy_from_user(cmdlist->data + cmdlist->last,
	598	(void __user *)cmd_gem,
	599	sizeof(cmd_gem) req->cmd_gem_nr)) {
	600	ret = -EFAULT;
	601	goto err_free_event;
	602	}
	603	cmdlist->last += req->cmd_gem_nr * 2;
	604
	605	ret = g2d_check_reg_offset(dev, cmdlist, req->cmd_gem_nr, true);
	606	if (ret < 0)
	607	goto err_free_event;
	608
	609	ret = g2d_get_cmdlist_gem(drm_dev, file, node);
	610	if (ret < 0)
	611	goto err_unmap;
	612	}
	613
	614	cmdlist->data[cmdlist->last++] = G2D_BITBLT_START;
	615	cmdlist->data[cmdlist->last++] = G2D_START_BITBLT;
	616
	617	/* head */
	618	cmdlist->head = cmdlist->last / 2;
	619
	620	/* tail */
	621	cmdlist->data[cmdlist->last] = 0;
	622
	623	g2d_add_cmdlist_to_inuse(g2d_priv, node);
	624
	625	return 0;
	626
	627	err_unmap:
	628	g2d_put_cmdlist_gem(drm_dev, file, node->gem_nr);
	629	err_free_event:
	630	if (node->event) {
	631	spin_lock_irqsave(&drm_dev->event_lock, flags);
	632	file->event_space += sizeof(e->event);
	633	spin_unlock_irqrestore(&drm_dev->event_lock, flags);
	634	kfree(node->event);
	635	}
	636	err:
	637	g2d_put_cmdlist(g2d, node);
	638	return ret;
	639	}
	640	EXPORT_SYMBOL_GPL(exynos_g2d_set_cmdlist_ioctl);
	641
	642	int exynos_g2d_exec_ioctl(struct drm_device drm_dev, void data,
	643	struct drm_file *file)
	644	{
	645	struct drm_exynos_file_private *file_priv = file->driver_priv;
	646	struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
	647	struct device *dev = g2d_priv->dev;
	648	struct g2d_data *g2d;
	649	struct drm_exynos_g2d_exec *req = data;
	650	struct g2d_runqueue_node *runqueue_node;
	651	struct list_head *run_cmdlist;
	652	struct list_head *event_list;
	653
	654	if (!dev)
	655	return -ENODEV;
	656
	657	g2d = dev_get_drvdata(dev);
	658	if (!g2d)
	659	return -EFAULT;
	660
	661	runqueue_node = kmem_cache_alloc(g2d->runqueue_slab, GFP_KERNEL);
	662	if (!runqueue_node) {
	663	dev_err(dev, "failed to allocate memory\n");
	664	return -ENOMEM;
	665	}
	666	run_cmdlist = &runqueue_node->run_cmdlist;
	667	event_list = &runqueue_node->event_list;
	668	INIT_LIST_HEAD(run_cmdlist);
	669	INIT_LIST_HEAD(event_list);
	670	init_completion(&runqueue_node->complete);
	671	runqueue_node->async = req->async;
	672
	673	list_splice_init(&g2d_priv->inuse_cmdlist, run_cmdlist);
	674	list_splice_init(&g2d_priv->event_list, event_list);
	675
	676	if (list_empty(run_cmdlist)) {
	677	dev_err(dev, "there is no inuse cmdlist\n");
	678	kmem_cache_free(g2d->runqueue_slab, runqueue_node);
	679	return -EPERM;
	680	}
	681
	682	mutex_lock(&g2d->runqueue_mutex);
	683	list_add_tail(&runqueue_node->list, &g2d->runqueue);
	684	if (!g2d->runqueue_node)
	685	g2d_exec_runqueue(g2d);
	686	mutex_unlock(&g2d->runqueue_mutex);
	687
	688	if (runqueue_node->async)
	689	goto out;
	690
	691	wait_for_completion(&runqueue_node->complete);
	692	g2d_free_runqueue_node(g2d, runqueue_node);
	693
	694	out:
	695	return 0;
	696	}
	697	EXPORT_SYMBOL_GPL(exynos_g2d_exec_ioctl);
	698
	699	static int g2d_open(struct drm_device drm_dev, struct device dev,
	700	struct drm_file *file)
	701	{
	702	struct drm_exynos_file_private *file_priv = file->driver_priv;
	703	struct exynos_drm_g2d_private *g2d_priv;
	704
	705	g2d_priv = kzalloc(sizeof(*g2d_priv), GFP_KERNEL);
	706	if (!g2d_priv) {
	707	dev_err(dev, "failed to allocate g2d private data\n");
	708	return -ENOMEM;
	709	}
	710
	711	g2d_priv->dev = dev;
	712	file_priv->g2d_priv = g2d_priv;
	713
	714	INIT_LIST_HEAD(&g2d_priv->inuse_cmdlist);
	715	INIT_LIST_HEAD(&g2d_priv->event_list);
	716	INIT_LIST_HEAD(&g2d_priv->gem_list);
	717
	718	return 0;
	719	}
	720
	721	static void g2d_close(struct drm_device drm_dev, struct device dev,
	722	struct drm_file *file)
	723	{
	724	struct drm_exynos_file_private *file_priv = file->driver_priv;
	725	struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
	726	struct g2d_data *g2d;
	727	struct g2d_cmdlist_node node, n;
	728
	729	if (!dev)
	730	return;
	731
	732	g2d = dev_get_drvdata(dev);
	733	if (!g2d)
	734	return;
	735
	736	mutex_lock(&g2d->cmdlist_mutex);
	737	list_for_each_entry_safe(node, n, &g2d_priv->inuse_cmdlist, list)
	738	list_move_tail(&node->list, &g2d->free_cmdlist);
	739	mutex_unlock(&g2d->cmdlist_mutex);
	740
	741	g2d_put_cmdlist_gem(drm_dev, file, g2d_priv->gem_nr);
	742
	743	kfree(file_priv->g2d_priv);
	744	}
	745
	746	static int __devinit g2d_probe(struct platform_device *pdev)
	747	{
	748	struct device *dev = &pdev->dev;
	749	struct resource *res;
	750	struct g2d_data *g2d;
	751	struct exynos_drm_subdrv *subdrv;
	752	int ret;
	753
	754	g2d = kzalloc(sizeof(*g2d), GFP_KERNEL);
	755	if (!g2d) {
	756	dev_err(dev, "failed to allocate driver data\n");
	757	return -ENOMEM;
	758	}
	759
	760	g2d->runqueue_slab = kmem_cache_create("g2d_runqueue_slab",
	761	sizeof(struct g2d_runqueue_node), 0, 0, NULL);
	762	if (!g2d->runqueue_slab) {
	763	ret = -ENOMEM;
	764	goto err_free_mem;
	765	}
	766
	767	g2d->dev = dev;
	768
	769	g2d->g2d_workq = create_singlethread_workqueue("g2d");
	770	if (!g2d->g2d_workq) {
	771	dev_err(dev, "failed to create workqueue\n");
	772	ret = -EINVAL;
	773	goto err_destroy_slab;
	774	}
	775
	776	INIT_WORK(&g2d->runqueue_work, g2d_runqueue_worker);
	777	INIT_LIST_HEAD(&g2d->free_cmdlist);
	778	INIT_LIST_HEAD(&g2d->runqueue);
	779
	780	mutex_init(&g2d->cmdlist_mutex);
	781	mutex_init(&g2d->runqueue_mutex);
	782
	783	ret = g2d_init_cmdlist(g2d);
	784	if (ret < 0)
	785	goto err_destroy_workqueue;
	786
	787	g2d->gate_clk = clk_get(dev, "fimg2d");
	788	if (IS_ERR(g2d->gate_clk)) {
	789	dev_err(dev, "failed to get gate clock\n");
	790	ret = PTR_ERR(g2d->gate_clk);
	791	goto err_fini_cmdlist;
	792	}
	793
	794	pm_runtime_enable(dev);
	795
	796	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	797	if (!res) {
	798	dev_err(dev, "failed to get I/O memory\n");
	799	ret = -ENOENT;
	800	goto err_put_clk;
	801	}
	802
	803	g2d->regs_res = request_mem_region(res->start, resource_size(res),
	804	dev_name(dev));
	805	if (!g2d->regs_res) {
	806	dev_err(dev, "failed to request I/O memory\n");
	807	ret = -ENOENT;
	808	goto err_put_clk;
	809	}
	810
	811	g2d->regs = ioremap(res->start, resource_size(res));
	812	if (!g2d->regs) {
	813	dev_err(dev, "failed to remap I/O memory\n");
	814	ret = -ENXIO;
	815	goto err_release_res;
	816	}
	817
	818	g2d->irq = platform_get_irq(pdev, 0);
	819	if (g2d->irq < 0) {
	820	dev_err(dev, "failed to get irq\n");
	821	ret = g2d->irq;
	822	goto err_unmap_base;
	823	}
	824
	825	ret = request_irq(g2d->irq, g2d_irq_handler, 0, "drm_g2d", g2d);
	826	if (ret < 0) {
	827	dev_err(dev, "irq request failed\n");
	828	goto err_unmap_base;
	829	}
	830
	831	platform_set_drvdata(pdev, g2d);
	832
	833	subdrv = &g2d->subdrv;
	834	subdrv->dev = dev;
	835	subdrv->open = g2d_open;
	836	subdrv->close = g2d_close;
	837
	838	ret = exynos_drm_subdrv_register(subdrv);
	839	if (ret < 0) {
	840	dev_err(dev, "failed to register drm g2d device\n");
	841	goto err_free_irq;
	842	}
	843
	844	dev_info(dev, "The exynos g2d(ver %d.%d) successfully probed\n",
	845	G2D_HW_MAJOR_VER, G2D_HW_MINOR_VER);
	846
	847	return 0;
	848
	849	err_free_irq:
	850	free_irq(g2d->irq, g2d);
	851	err_unmap_base:
	852	iounmap(g2d->regs);
	853	err_release_res:
	854	release_resource(g2d->regs_res);
	855	kfree(g2d->regs_res);
	856	err_put_clk:
	857	pm_runtime_disable(dev);
	858	clk_put(g2d->gate_clk);
	859	err_fini_cmdlist:
	860	g2d_fini_cmdlist(g2d);
	861	err_destroy_workqueue:
	862	destroy_workqueue(g2d->g2d_workq);
	863	err_destroy_slab:
	864	kmem_cache_destroy(g2d->runqueue_slab);
	865	err_free_mem:
	866	kfree(g2d);
	867	return ret;
	868	}
	869
	870	static int __devexit g2d_remove(struct platform_device *pdev)
	871	{
	872	struct g2d_data *g2d = platform_get_drvdata(pdev);
	873
	874	cancel_work_sync(&g2d->runqueue_work);
	875	exynos_drm_subdrv_unregister(&g2d->subdrv);
	876	free_irq(g2d->irq, g2d);
	877
	878	while (g2d->runqueue_node) {
	879	g2d_free_runqueue_node(g2d, g2d->runqueue_node);
	880	g2d->runqueue_node = g2d_get_runqueue_node(g2d);
	881	}
	882
	883	iounmap(g2d->regs);
	884	release_resource(g2d->regs_res);
	885	kfree(g2d->regs_res);
	886
	887	pm_runtime_disable(&pdev->dev);
	888	clk_put(g2d->gate_clk);
	889
	890	g2d_fini_cmdlist(g2d);
	891	destroy_workqueue(g2d->g2d_workq);
	892	kmem_cache_destroy(g2d->runqueue_slab);
	893	kfree(g2d);
	894
	895	return 0;
	896	}
	897
	898	#ifdef CONFIG_PM_SLEEP
	899	static int g2d_suspend(struct device *dev)
	900	{
	901	struct g2d_data *g2d = dev_get_drvdata(dev);
	902
	903	mutex_lock(&g2d->runqueue_mutex);
	904	g2d->suspended = true;
	905	mutex_unlock(&g2d->runqueue_mutex);
	906
	907	while (g2d->runqueue_node)
	908	/* FIXME: good range? */
	909	usleep_range(500, 1000);
	910
	911	flush_work_sync(&g2d->runqueue_work);
	912
	913	return 0;
	914	}
	915
	916	static int g2d_resume(struct device *dev)
	917	{
	918	struct g2d_data *g2d = dev_get_drvdata(dev);
	919
	920	g2d->suspended = false;
	921	g2d_exec_runqueue(g2d);
	922
	923	return 0;
	924	}
	925	#endif
	926
	927	SIMPLE_DEV_PM_OPS(g2d_pm_ops, g2d_suspend, g2d_resume);
	928
	929	struct platform_driver g2d_driver = {
	930	.probe = g2d_probe,
	931	.remove = __devexit_p(g2d_remove),
	932	.driver = {
	933	.name = "s5p-g2d",
	934	.owner = THIS_MODULE,
	935	.pm = &g2d_pm_ops,
	936	},
	937	};
	938

drivers/gpu/drm/exynos/exynos_drm_g2d.h

Diff comments View file @ d7f1642

File was created	1	/*
	2	* Copyright (C) 2012 Samsung Electronics Co.Ltd
	3	* Authors: Joonyoung Shim <jy0922.shim@samsung.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundationr
	8	*/
	9
	10	#ifdef CONFIG_DRM_EXYNOS_G2D
	11	extern int exynos_g2d_get_ver_ioctl(struct drm_device dev, void data,
	12	struct drm_file *file_priv);
	13	extern int exynos_g2d_set_cmdlist_ioctl(struct drm_device dev, void data,
	14	struct drm_file *file_priv);
	15	extern int exynos_g2d_exec_ioctl(struct drm_device dev, void data,
	16	struct drm_file *file_priv);
	17	#else
	18	static inline int exynos_g2d_get_ver_ioctl(struct drm_device dev, void data,
	19	struct drm_file *file_priv)
	20	{
	21	return -ENODEV;
	22	}
	23
	24	static inline int exynos_g2d_set_cmdlist_ioctl(struct drm_device *dev,
	25	void *data,
	26	struct drm_file *file_priv)
	27	{
	28	return -ENODEV;
	29	}
	30
	31	static inline int exynos_g2d_exec_ioctl(struct drm_device dev, void data,
	32	struct drm_file *file_priv)
	33	{
	34	return -ENODEV;
	35	}
	36	#endif
	37

include/drm/exynos_drm.h

Diff comments View file @ d7f1642

 /* exynos_drm.h
  *
  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
  * Authors:
  *	Inki Dae <inki.dae@samsung.com>
  *	Joonyoung Shim <jy0922.shim@samsung.com>
  *	Seung-Woo Kim <sw0312.kim@samsung.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 #ifndef _EXYNOS_DRM_H_
 #define _EXYNOS_DRM_H_
+#include "drm.h"
 /**
  * User-desired buffer creation information structure.
  *
  * @size: user-desired memory allocation size.
  *	- this size value would be page-aligned internally.
  * @flags: user request for setting memory type or cache attributes.
  * @handle: returned a handle to created gem object.
  *	- this handle will be set by gem module of kernel side.
  */
 struct drm_exynos_gem_create {
 	uint64_t size;
 	unsigned int flags;
 	unsigned int handle;
 };
 /**
  * A structure for getting buffer offset.
  *
  * @handle: a pointer to gem object created.
  * @pad: just padding to be 64-bit aligned.
  * @offset: relatived offset value of the memory region allocated.
  *	- this value should be set by user.
  */
 struct drm_exynos_gem_map_off {
 	unsigned int handle;
 	unsigned int pad;
 	uint64_t offset;
 };
 /**
  * A structure for mapping buffer.
  *
  * @handle: a handle to gem object created.
  * @size: memory size to be mapped.
  * @mapped: having user virtual address mmaped.
  *	- this variable would be filled by exynos gem module
  *	of kernel side with user virtual address which is allocated
  *	by do_mmap().
  */
 struct drm_exynos_gem_mmap {
 	unsigned int handle;
 	unsigned int size;
 	uint64_t mapped;
 };
 /**
  * A structure to gem information.
  *
  * @handle: a handle to gem object created.
  * @flags: flag value including memory type and cache attribute and
  *	this value would be set by driver.
  * @size: size to memory region allocated by gem and this size would
  *	be set by driver.
  */
 struct drm_exynos_gem_info {
 	unsigned int handle;
 	unsigned int flags;
 	uint64_t size;
 };
 /**
  * A structure for user connection request of virtual display.
  *
  * @connection: indicate whether doing connetion or not by user.
  * @extensions: if this value is 1 then the vidi driver would need additional
  *	128bytes edid data.
  * @edid: the edid data pointer from user side.
  */
 struct drm_exynos_vidi_connection {
 	unsigned int connection;
 	unsigned int extensions;
 	uint64_t edid;
 };
 struct drm_exynos_plane_set_zpos {
 	__u32 plane_id;
 	__s32 zpos;
 };
 /* memory type definitions. */
 enum e_drm_exynos_gem_mem_type {
 	/* Physically Continuous memory and used as default. */
 	EXYNOS_BO_CONTIG	= 0 << 0,
 	/* Physically Non-Continuous memory. */
 	EXYNOS_BO_NONCONTIG	= 1 << 0,
 	/* non-cachable mapping and used as default. */
 	EXYNOS_BO_NONCACHABLE	= 0 << 1,
 	/* cachable mapping. */
 	EXYNOS_BO_CACHABLE	= 1 << 1,
 	/* write-combine mapping. */
 	EXYNOS_BO_WC		= 1 << 2,
 	EXYNOS_BO_MASK		= EXYNOS_BO_NONCONTIG | EXYNOS_BO_CACHABLE |
 					EXYNOS_BO_WC
 };
+struct drm_exynos_g2d_get_ver {
+	__u32	major;
+	__u32	minor;
+};
+struct drm_exynos_g2d_cmd {
+	__u32	offset;
+	__u32	data;
+};
+enum drm_exynos_g2d_event_type {
+	G2D_EVENT_NOT,
+	G2D_EVENT_NONSTOP,
+	G2D_EVENT_STOP,		/* not yet */
+};
+struct drm_exynos_g2d_set_cmdlist {
+	__u64					cmd;
+	__u64					cmd_gem;
+	__u32					cmd_nr;
+	__u32					cmd_gem_nr;
+	/* for g2d event */
+	__u64					event_type;
+	__u64					user_data;
+};
+struct drm_exynos_g2d_exec {
+	__u64					async;
+};
 #define DRM_EXYNOS_GEM_CREATE		0x00
 #define DRM_EXYNOS_GEM_MAP_OFFSET	0x01
 #define DRM_EXYNOS_GEM_MMAP		0x02
 /* Reserved 0x03 ~ 0x05 for exynos specific gem ioctl */
 #define DRM_EXYNOS_GEM_GET		0x04
 #define DRM_EXYNOS_PLANE_SET_ZPOS	0x06
 #define DRM_EXYNOS_VIDI_CONNECTION	0x07
+/* G2D */
+#define DRM_EXYNOS_G2D_GET_VER		0x20
+#define DRM_EXYNOS_G2D_SET_CMDLIST	0x21
+#define DRM_EXYNOS_G2D_EXEC		0x22
 #define DRM_IOCTL_EXYNOS_GEM_CREATE		DRM_IOWR(DRM_COMMAND_BASE + \
 		DRM_EXYNOS_GEM_CREATE, struct drm_exynos_gem_create)
 #define DRM_IOCTL_EXYNOS_GEM_MAP_OFFSET	DRM_IOWR(DRM_COMMAND_BASE + \
 		DRM_EXYNOS_GEM_MAP_OFFSET, struct drm_exynos_gem_map_off)
 #define DRM_IOCTL_EXYNOS_GEM_MMAP	DRM_IOWR(DRM_COMMAND_BASE + \
 		DRM_EXYNOS_GEM_MMAP, struct drm_exynos_gem_mmap)
 #define DRM_IOCTL_EXYNOS_GEM_GET	DRM_IOWR(DRM_COMMAND_BASE + \
 		DRM_EXYNOS_GEM_GET,	struct drm_exynos_gem_info)
 #define DRM_IOCTL_EXYNOS_PLANE_SET_ZPOS	DRM_IOWR(DRM_COMMAND_BASE + \
 		DRM_EXYNOS_PLANE_SET_ZPOS, struct drm_exynos_plane_set_zpos)
 #define DRM_IOCTL_EXYNOS_VIDI_CONNECTION	DRM_IOWR(DRM_COMMAND_BASE + \
 		DRM_EXYNOS_VIDI_CONNECTION, struct drm_exynos_vidi_connection)
+#define DRM_IOCTL_EXYNOS_G2D_GET_VER		DRM_IOWR(DRM_COMMAND_BASE + \
+		DRM_EXYNOS_G2D_GET_VER, struct drm_exynos_g2d_get_ver)
+#define DRM_IOCTL_EXYNOS_G2D_SET_CMDLIST	DRM_IOWR(DRM_COMMAND_BASE + \
+		DRM_EXYNOS_G2D_SET_CMDLIST, struct drm_exynos_g2d_set_cmdlist)
+#define DRM_IOCTL_EXYNOS_G2D_EXEC		DRM_IOWR(DRM_COMMAND_BASE + \
+		DRM_EXYNOS_G2D_EXEC, struct drm_exynos_g2d_exec)
+/* EXYNOS specific events */
+#define DRM_EXYNOS_G2D_EVENT		0x80000000
+struct drm_exynos_g2d_event {
+	struct drm_event	base;
+	__u64			user_data;
+	__u32			tv_sec;
+	__u32			tv_usec;
+	__u32			cmdlist_no;
+	__u32			reserved;
+};
 #ifdef __KERNEL__
 /**
  * A structure for lcd panel information.
  *
  * @timing: default video mode for initializing
  * @width_mm: physical size of lcd width.
  * @height_mm: physical size of lcd height.
  */
 struct exynos_drm_panel_info {
 	struct fb_videomode timing;
 	u32 width_mm;
 	u32 height_mm;
 };
 /**
  * Platform Specific Structure for DRM based FIMD.
  *
  * @panel: default panel info for initializing
  * @default_win: default window layer number to be used for UI.
  * @bpp: default bit per pixel.
  */
 struct exynos_drm_fimd_pdata {
 	struct exynos_drm_panel_info panel;
 	u32				vidcon0;
 	u32				vidcon1;
 	unsigned int			default_win;
 	unsigned int			bpp;
 };
 /**
  * Platform Specific Structure for DRM based HDMI.
  *
  * @hdmi_dev: device point to specific hdmi driver.
  * @mixer_dev: device point to specific mixer driver.
  *
  * this structure is used for common hdmi driver and each device object
  * would be used to access specific device driver(hdmi or mixer driver)
  */
 struct exynos_drm_common_hdmi_pd {
 	struct device *hdmi_dev;
 	struct device *mixer_dev;
 };
 /**
  * Platform Specific Structure for DRM based HDMI core.
  *
  * @is_v13: set if hdmi version 13 is.
  * @cfg_hpd: function pointer to configure hdmi hotplug detection pin
  * @get_hpd: function pointer to get value of hdmi hotplug detection pin
  */
 struct exynos_drm_hdmi_pdata {
 	bool is_v13;
 	void (*cfg_hpd)(bool external);
 	int (*get_hpd)(void);
 };
 #endif	/* __KERNEL__ */
 #endif	/* _EXYNOS_DRM_H_ */