dri-devel August 2011

dri-devel@lists.freedesktop.org

77 participants
464 discussions

[RFC] Standardize YUV support in the fbdev API
by Laurent Pinchart 13 Aug '11

13 Aug '11

Hi everybody, I need to implement support for a YUV frame buffer in an fbdev driver. As the fbdev API doesn't support this out of the box, I've spent a couple of days reading fbdev (and KMS) code and thinking about how we could cleanly add YUV support to the API. I'd like to share my findings and thoughts, and hopefully receive some comments back. The terms 'format', 'pixel format', 'frame buffer format' and 'data format' will be used interchangeably in this e-mail. They all refer to the way pixels are stored in memory, including both the representation of a pixel as integer values and the layout of those integer values in memory. History and current situation ----------------------------- The fbdev API predates YUV frame buffers. In those old days developers only cared (and probably thought) about RGB frame buffers, and they developed an API that could express all kind of weird RGB layout in memory (such as R- GGGGGGGGGGG-BBBB for instance, I can't imagine hardware implementing that). This resulted in individual bit field description for the red, green, blue and alpha components: struct fb_bitfield { __u32 offset; /* beginning of bitfield */ __u32 length; /* length of bitfield */ __u32 msb_right; /* != 0 : Most significant bit is */ /* right */ }; Grayscale formats were pretty common, so a grayscale field tells color formats (grayscale == 0) from grayscale formats (grayscale != 0). People already realized that hardware developers were crazily inventive (the word to remember here is crazily), and that non-standard formats would be needed at some point. The fb_var_screeninfo ended up containing the following format-related fields. struct fb_var_screeninfo { ... __u32 bits_per_pixel; /* guess what */ __u32 grayscale; /* != 0 Graylevels instead of colors */ struct fb_bitfield red; /* bitfield in fb mem if true color, */ struct fb_bitfield green; /* else only length is significant */ struct fb_bitfield blue; struct fb_bitfield transp; /* transparency */ __u32 nonstd; /* != 0 Non standard pixel format */ ... }; Two bits have been specified for the nonstd field: #define FB_NONSTD_HAM 1 /* Hold-And-Modify (HAM) */ #define FB_NONSTD_REV_PIX_IN_B 2 /* order of pixels in each byte is reversed */ The FB_NONSTD_HAM bit is used by the video/amifb.c driver only to enable HAM mode[1]. I very much doubt that any new hardware will implement HAM mode (and I certainly hope none will). The FB_NONSTD_REV_PIX_IN_B is used in video/fb_draw.h by the generic bitblit, fillrect and copy area implementations, not directly by drivers. A couple of drivers hardcode the nonstd field to 1 for some reason. Those are video/arcfb.c (1bpp gray display), video/hecubafb.c (1bpp gray display) and video/metronomefb.c (8bpp gray display). The following drivers use nonstd for various other (and sometimes weird) purposes: video/arkfb.c Used in 4bpp mode only, to control fb_setcolreg operation video/fsl-diu-fb.c Set var->nonstd bits into var->sync (why?) video/pxafb.c Encode frame buffer xpos and ypos in the nonstd field video/s3fb.c Used in 4bpp mode only, to control fb_setcolreg operation video/vga16fb.c When panning in non-8bpp, non-text mode, decrement xoffset Do some other weird stuff when not 0 video/i810/i810_main.c Select direct color mode when set to 1 (truecolor otherwise) Fast forward a couple of years, hardware provides support for YUV frame buffers. Several drivers had to provide YUV format selection to applications, without any standard API to do so. All of them used the nonstd field for that purpose: media/video/ivtv/ Enable YUV mode when set to 1 video/pxafb.c Encode pixel format in the nonstd field video/sh_mobile_lcdfb.c If bpp == 12 and nonstd != 0, enable NV12 mode If bpp == 16 or bpp == 24, ? video/omap/omapfb_main.c Select direct color mode when set to 1 (depend on bpp otherwise) Used as a pixel format identifier (YUV422, YUV420 or YUY422) video/omap2/omapfb/omapfb-main.c Select direct color mode when set to 1 (depend on bpp otherwise) Used as a pixel format identifier (YUV422 or YUY422) Those drivers use the nonstd field in different, incompatible ways. Other related APIs ------------------ Beside the fbdev API, two other kernel/userspace APIs deal with video-related modes and formats. - Kernel Mode Setting (KMS) The KMS API is similar in purpose to XRandR. Its main purpose is to provide a kernel API to configure output video modes. As such, it doesn't care about frame buffer formats, as they are irrelevant at the CRTC output. In addition to handling video modes, the KMS API also provides support for creating (and managing) frame buffer devices, as well as dumb scan-out buffers. In-memory data format is relevant there, but KMS only handles width, height, pitch, depth and bit-per-pixel information. The API doesn't care whether the frame buffer or the dumb scan-out buffer contains RGB or YUV data. An RFC[2] has recently been posted to the dri-devel mailing list to "add overlays as first class KMS objects". The proposal includes explicit overlay format support, and discussions have so far pushed towards reusing V4L format codes for the KMS API. - Video 4 Linux (V4L) The V4L API version 2 (usually called V4L2) has since the beginning included explicit support for data format, referred to as pixel formats. Pixel formats are identified by a 32-bit number in the form of a four characters code (4CC or FCC[3]). The list of FCCs defined by V4L2 is available in [4]. A pixel format uniquely defines the layout of pixel data in memory, including the format type (RGB, YUV, ...), number of bits per components, components order and subsampling. It doesn't define the range of acceptable values for pixel components (such as full-range YUV vs. BT.601[5]), which is carried through a separate colorspace identifier[6]. YUV support in the fbdev API ---------------------------- Experience with the V4L2 API, both for desktop and embedded devices, and the KMS API, suggests that recent hardware tend to standardize on a relatively small number of pixel formats that don't require bitfield-level descriptions. A pixel format definition based on identifiers should thus fullfill the hardware needs for the foreseeable future. Given the overlap between the KMS, V4L2 and fbdev APIs, the need to share data and buffers between those subsystems, and the planned use of V4L2 FCCs in the KMS overlay API, I believe using V4L2 FCCs to identify fbdev formats would be a wise decision. To select a frame buffer YUV format, the fb_var_screeninfo structure will need to be extended with a format field. The fbdev API and ABI must not be broken, which prevents us from changing the current structure layout and replacing the existing format selection mechanism (through the red, green, blue and alpha bitfields) completely. Several solutions exist to introduce a format field in the fb_var_screeninfo structure. - Use the nonstd field as a format identifier. Existing drivers that use the nonstd field for other purposes wouldn't be able to implement the new API while keeping their existing API. This isn't a show stopper for drivers using the FB_NONSTD_HAM and FB_NONSTD_REV_PIX_IN_B bits, as they don't need to support any non-RGB format. Existing drivers that support YUV formats through the nonstd field would have to select between the current and the new API, without being able to implement both. - Use one of the reserved fields as a format identifier. Applications are supposed to zero the fb_var_screeninfo structure before passing it to the kernel, but experience showed that many applications forget to do so. Drivers would then be unable to find out whether applications request a particular format, or just forgot to initialize the field. - Add a new FB_NONSTD_FORMAT bit to the nonstd field, and pass the format through a separate field. If an application sets the FB_NONSTD_FORMAT bit in the nonstd field, drivers will ignore the red, green, blue, transp and grayscale fields, and use the format identifier to configure the frame buffer format. The grayscale field would then be unneeded and could be reused as a format identifier. Alternatively, one of the reserved fields could be used for that purpose. Existing drivers that support YUV formats through the nonstd field don't use the field's most significant bits. They could implement both their current API and the new API if the FB_NONSTD_FORMAT bit is stored in one of the nonstd MSBs. - Other solutions are possible, such as adding new ioctls. Those solutions are more intrusive, and require larger changes to both userspace and kernelspace code. The third solution has my preference. Comments and feedback will be appreciated. I will then work on a proof of concept and submit patches. [1] http://en.wikipedia.org/wiki/Hold_And_Modify [2] http://lwn.net/Articles/440192/ [3] http://www.fourcc.org/ [4] http://lxr.linux.no/linux+v2.6.38/include/linux/videodev2.h#L271 [5] http://en.wikipedia.org/wiki/Rec._601 [6] http://lxr.linux.no/linux+v2.6.38/include/linux/videodev2.h#L175 -- Regards, Laurent Pinchart

9 31

[RFC][PATCH v2] DRM: add DRM Driver for Samsung SoC EXYNOS4210.
by Inki Dae 12 Aug '11

12 Aug '11

This patch is a DRM Driver(only including FIMD Driver yet) for Samsung SoC Exynos4210. and as 2nd RFC, I am sending only DRM driver part. this patch is based on git repository below: git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6.git, branch: drm-next commit-id: 5a96a899bbdee86024ab9ea6d02b9e242faacbed We tried to re-use lowlevel codes of the FIMD driver(s3c-fb.c based on Linux framebuffer) but couldn't so because lowlevel codes of s3c-fb.c are included internally and so this driver shares only platform device. Sub drivers such as fimd or hdmi have indenpendent platform device and Platform driver and when driver's probe is called, the driver object including callbacks(for hardware control) would be registered to Samsung drm driver. and then when samsung drm driver is probed, each probe callback of the driver object registered is called so that additional callbacks for drm framework would be set at this time. We used GEM framework for buffer management and this driver supports only physically continuous memory yet(non-iommu). and for buffer allocation, we used DMA APIs(dma_alloc_writecombine) but we will change it to CMA instead of DMA APIs later. Refer to this link for CMA(Continuous Memory Allocator): http://lkml.org/lkml/2011/7/20/45 Links to previous versions of the patchset: v1: < https://lwn.net/Articles/454380/> Changelog: DRM: add DRM_IOCTL_SAMSUNG_GEM_MMAP ioctl command. this feature maps user address space to physical memory region once user application requests DRM_IOCTL_SAMSUNG_GEM_MMAP ioctl. DRM: code clean and add exception codes. Signed-off-by: Inki Dae <inki.dae(a)samsung.com> Signed-off-by: Joonyoung Shim <jy0922.shim(a)samsung.com> Signed-off-by: Kyungmin Park <kyungmin.park(a)samsung.com> --- arch/arm/plat-samsung/include/plat/samsung_drm.h | 62 +++ drivers/gpu/drm/Kconfig | 10 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/samsung/Makefile | 10 + drivers/gpu/drm/samsung/samsung_drm_buf.c | 140 +++++ drivers/gpu/drm/samsung/samsung_drm_buf.h | 78 +++ drivers/gpu/drm/samsung/samsung_drm_common.h | 40 ++ drivers/gpu/drm/samsung/samsung_drm_connector.c | 355 +++++++++++++ drivers/gpu/drm/samsung/samsung_drm_connector.h | 39 ++ drivers/gpu/drm/samsung/samsung_drm_crtc.c | 304 +++++++++++ drivers/gpu/drm/samsung/samsung_drm_crtc.h | 50 ++ drivers/gpu/drm/samsung/samsung_drm_drv.c | 384 ++++++++++++++ drivers/gpu/drm/samsung/samsung_drm_encoder.c | 233 +++++++++ drivers/gpu/drm/samsung/samsung_drm_encoder.h | 37 ++ drivers/gpu/drm/samsung/samsung_drm_fb.c | 288 ++++++++++ drivers/gpu/drm/samsung/samsung_drm_fb.h | 46 ++ drivers/gpu/drm/samsung/samsung_drm_fbdev.c | 329 ++++++++++++ drivers/gpu/drm/samsung/samsung_drm_fbdev.h | 38 ++ drivers/gpu/drm/samsung/samsung_drm_fimd.c | 609 ++++++++++++++++++++++ drivers/gpu/drm/samsung/samsung_drm_gem.c | 492 +++++++++++++++++ drivers/gpu/drm/samsung/samsung_drm_gem.h | 76 +++ include/drm/samsung_drm.h | 274 ++++++++++ 22 files changed, 3895 insertions(+), 0 deletions(-) create mode 100644 arch/arm/plat-samsung/include/plat/samsung_drm.h create mode 100644 drivers/gpu/drm/samsung/Makefile create mode 100644 drivers/gpu/drm/samsung/samsung_drm_buf.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_buf.h create mode 100644 drivers/gpu/drm/samsung/samsung_drm_common.h create mode 100644 drivers/gpu/drm/samsung/samsung_drm_connector.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_connector.h create mode 100644 drivers/gpu/drm/samsung/samsung_drm_crtc.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_crtc.h create mode 100644 drivers/gpu/drm/samsung/samsung_drm_drv.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_encoder.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_encoder.h create mode 100644 drivers/gpu/drm/samsung/samsung_drm_fb.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_fb.h create mode 100644 drivers/gpu/drm/samsung/samsung_drm_fbdev.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_fbdev.h create mode 100644 drivers/gpu/drm/samsung/samsung_drm_fimd.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_gem.c create mode 100644 drivers/gpu/drm/samsung/samsung_drm_gem.h create mode 100644 include/drm/samsung_drm.h diff --git a/arch/arm/plat-samsung/include/plat/samsung_drm.h b/arch/arm/plat-samsung/include/plat/samsung_drm.h new file mode 100644 index 0000000..7b5e734 --- /dev/null +++ b/arch/arm/plat-samsung/include/plat/samsung_drm.h @@ -0,0 +1,62 @@ +/* samsung_drm.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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. + */ + +enum samsung_drm_output_type { + SAMSUNG_DISPLAY_TYPE_NONE, + SAMSUNG_DISPLAY_TYPE_LCD, /* RGB or CPU Interface. */ + SAMSUNG_DISPLAY_TYPE_MIPI, /* MIPI-DSI Interface. */ + SAMSUNG_DISPLAY_TYPE_HDMI, /* HDMI Interface. */ + SAMSUNG_DISPLAY_TYPE_VENC, +}; + +struct samsung_video_timings { + u16 x_res; + u16 y_res; + u16 hsw; + u16 hfp; + u16 hbp; + u16 vsw; + u16 vfp; + u16 vbp; + u32 framerate; + u32 vclk; /* Hz, calcurate from driver */ +}; + +struct samsung_drm_subdrv_data { + unsigned int display_type; + unsigned int overlay_num; + unsigned int bpp; +}; + +struct samsung_drm_fimd_pdata { + struct samsung_drm_subdrv_data subdrv_data; + struct samsung_video_timings timing; + void (*setup_gpio)(void); + u32 vidcon0; + u32 vidcon1; +}; diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index b493663..3a0eac0 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -158,3 +158,13 @@ config DRM_SAVAGE help Choose this option if you have a Savage3D/4/SuperSavage/Pro/Twister chipset. If M is selected the module will be called savage. + +config DRM_SAMSUNG + 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 + help + Choose this option if you have a Samsung SoC EXYNOS chipset. diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 89cf05a..0c6e773 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -35,4 +35,5 @@ obj-$(CONFIG_DRM_SAVAGE)+= savage/ obj-$(CONFIG_DRM_VMWGFX)+= vmwgfx/ obj-$(CONFIG_DRM_VIA) +=via/ obj-$(CONFIG_DRM_NOUVEAU) +=nouveau/ +obj-$(CONFIG_DRM_SAMSUNG) +=samsung/ obj-y += i2c/ diff --git a/drivers/gpu/drm/samsung/Makefile b/drivers/gpu/drm/samsung/Makefile new file mode 100644 index 0000000..33504fa --- /dev/null +++ b/drivers/gpu/drm/samsung/Makefile @@ -0,0 +1,10 @@ +# +# 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/samsung -Idrivers/gpu/drm/samsung/ump/include +samsungdrm-y := samsung_drm_drv.o samsung_drm_encoder.o samsung_drm_connector.o \ + samsung_drm_crtc.o samsung_drm_fbdev.o samsung_drm_fb.o \ + samsung_drm_buf.o samsung_drm_fimd.o samsung_drm_gem.o + +obj-$(CONFIG_DRM_SAMSUNG) += samsungdrm.o diff --git a/drivers/gpu/drm/samsung/samsung_drm_buf.c b/drivers/gpu/drm/samsung/samsung_drm_buf.c new file mode 100644 index 0000000..65e92db --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_buf.c @@ -0,0 +1,140 @@ +/* samsung_drm_buf.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Author: Inki Dae <inki.dae(a)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 <plat/samsung_drm.h> + +#include "samsung_drm_buf.h" + +static DEFINE_MUTEX(samsung_drm_buf_lock); + +static int lowlevel_buffer_allocate(struct drm_device *dev, + struct samsung_drm_buf_entry *entry) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + entry->vaddr = dma_alloc_writecombine(dev->dev, entry->size, + (dma_addr_t *)&entry->paddr, GFP_KERNEL); + if (!entry->paddr) { + DRM_ERROR("failed to allocate buffer.\n"); + return -ENOMEM; + } + + DRM_DEBUG_KMS("allocated : vaddr(0x%x), paddr(0x%x), size(0x%x)\n", + (unsigned int)entry->vaddr, entry->paddr, entry->size); + + return 0; +} + +static void lowlevel_buffer_deallocate(struct drm_device *dev, + struct samsung_drm_buf_entry *entry) +{ + DRM_DEBUG_KMS("%s.\n", __FILE__); + + dma_free_writecombine(dev->dev, entry->size, entry->vaddr, + entry->paddr); + + DRM_DEBUG_KMS("deallocated : vaddr(0x%x), paddr(0x%x), size(0x%x)\n", + (unsigned int)entry->vaddr, entry->paddr, entry->size); +} + +static void samsung_drm_buf_del(struct drm_device *dev, + struct samsung_drm_gem_obj *obj) +{ + DRM_DEBUG_KMS("%s.\n", __FILE__); + + lowlevel_buffer_deallocate(dev, obj->entry); + + kfree(obj->entry); + + kfree(obj); +} + +struct samsung_drm_gem_obj *samsung_drm_buf_new(struct drm_device *dev, + unsigned int size) +{ + struct samsung_drm_gem_obj *obj; + struct samsung_drm_buf_entry *entry; + int ret; + + DRM_DEBUG_KMS("%s.\n", __FILE__); + DRM_DEBUG_KMS("desired size = 0x%x\n", size); + + obj = kzalloc(sizeof(*obj), GFP_KERNEL); + if (!obj) { + DRM_ERROR("failed to allocate samsung_drm_gem_obj.\n"); + return NULL; + } + + /* use only one memory plane yet. */ + entry = kzalloc(sizeof(*entry), GFP_KERNEL); + if (!entry) { + DRM_ERROR("failed to allocate samsung_drm_buf_entry.\n"); + return NULL; + } + + entry->size = size; + + /* allocate memory region and set it to vaddr and paddr. */ + ret = lowlevel_buffer_allocate(dev, entry); + if (ret < 0) + return NULL; + + obj->entry = entry; + + return obj; +} + +struct samsung_drm_gem_obj *samsung_drm_buf_create(struct drm_device *dev, + unsigned int size) +{ + struct samsung_drm_gem_obj *obj; + + DRM_DEBUG_KMS("%s.\n", __FILE__); + + obj = samsung_drm_buf_new(dev, size); + if (!obj) + return NULL; + + DRM_DEBUG_KMS("buffer id : 0x%x\n", obj->id); + + return obj; +} + +int samsung_drm_buf_destroy(struct drm_device *dev, + struct samsung_drm_gem_obj *in_obj) +{ + DRM_DEBUG_KMS("%s.\n", __FILE__); + + samsung_drm_buf_del(dev, in_obj); + + return 0; +} + +MODULE_AUTHOR("Inki Dae <inki.dae(a)samsung.com>"); +MODULE_DESCRIPTION("Samsung SoC DRM Buffer Management Module"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/samsung/samsung_drm_buf.h b/drivers/gpu/drm/samsung/samsung_drm_buf.h new file mode 100644 index 0000000..d6a7e95 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_buf.h @@ -0,0 +1,78 @@ +/* samsung_drm_buf.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Author: Inki Dae <inki.dae(a)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 _SAMSUNG_DRM_BUF_H_ +#define _SAMSUNG_DRM_BUF_H_ + +/** + * samsung drm buffer entry structure. + * + * @paddr: physical address of allocated memory. + * @vaddr: kernel virtual address of allocated memory. + * @size: size of allocated memory. + */ +struct samsung_drm_buf_entry { + unsigned int paddr; + void __iomem *vaddr; + unsigned int size; +}; + +/** + * samsung drm buffer structure. + * + * @entry: pointer to samsung drm buffer entry object. + * @flags: it means memory type to be alloated or cache attributes. + * @handle: pointer to specific buffer object. + * @id: unique id to specific buffer object. + * + * ps. this object would be transfered to user as kms_bo.handle so + * user can access to memory through kms_bo.handle. + */ +struct samsung_drm_gem_obj { + struct drm_gem_object base; + struct samsung_drm_buf_entry *entry; + unsigned int flags; + + unsigned int handle; + unsigned int id; +}; + +/* create new buffer object and memory region and add the object to list. */ +struct samsung_drm_gem_obj *samsung_drm_buf_new(struct drm_device *dev, + unsigned int size); + +/* allocate physical memory and add its object to list. */ +struct samsung_drm_gem_obj *samsung_drm_buf_create(struct drm_device *dev, + unsigned int size); + +/* remove allocated physical memory. */ +int samsung_drm_buf_destroy(struct drm_device *dev, + struct samsung_drm_gem_obj *in_obj); + +/* find object added to list. */ +struct samsung_drm_gem_obj *samsung_drm_buffer_find(struct drm_device *dev, + struct samsung_drm_gem_obj *in_obj, unsigned int paddr); + +#endif diff --git a/drivers/gpu/drm/samsung/samsung_drm_common.h b/drivers/gpu/drm/samsung/samsung_drm_common.h new file mode 100644 index 0000000..ba92b87 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_common.h @@ -0,0 +1,40 @@ +/* samsung_drm_common.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Autohr: Inki Dae <inki.dae(a)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 _SAMSUNG_DRM_COMMON_H +#define _SAMSUNG_DRM_COMMON_H + +/* get samsung_drm_manager from drm_encoder. */ +struct samsung_drm_manager * +samsung_drm_get_manager(struct drm_encoder *encoder); + +/* get drm_encoder from drm_connector. */ +struct drm_encoder * + samsung_drm_get_attached_encoder(struct drm_connector *connector); + +struct samsung_drm_display * + get_display_from_connector(struct drm_connector *connector); + +#endif diff --git a/drivers/gpu/drm/samsung/samsung_drm_connector.c b/drivers/gpu/drm/samsung/samsung_drm_connector.c new file mode 100644 index 0000000..6beb973 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_connector.c @@ -0,0 +1,355 @@ +/* samsung_drm_connector.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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_crtc_helper.h" + +#include <drm/samsung_drm.h> +#include <plat/samsung_drm.h> + +#include "samsung_drm_common.h" + +#define MAX_EDID 256 +#define to_samsung_connector(x) container_of(x, struct samsung_drm_connector,\ + drm_connector); + +struct samsung_drm_connector { + struct drm_connector drm_connector; + struct samsung_drm_display *display; +}; + +/* convert samsung_video_timings to drm_display_mode. */ +static inline void convert_to_display_mode(struct samsung_video_timings *timing, + struct drm_display_mode *mode) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + mode->clock = timing->vclk / 1000; + + mode->hdisplay = timing->x_res; + mode->hsync_start = mode->hdisplay + timing->hfp; + mode->hsync_end = mode->hsync_start + timing->hsw; + mode->htotal = mode->hsync_end + timing->hbp; + + mode->vdisplay = timing->y_res; + mode->vsync_start = mode->vdisplay + timing->vfp; + mode->vsync_end = mode->vsync_start + timing->vsw; + mode->vtotal = mode->vsync_end + timing->vbp; +} + +/* convert drm_display_mode to samsung_video_timings. */ +static inline void convert_to_video_timing(struct drm_display_mode *mode, + struct samsung_video_timings *timing) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + timing->vclk = mode->clock * 1000; + + timing->x_res = mode->hdisplay; + timing->hfp = mode->hsync_start - mode->hdisplay; + timing->hsw = mode->hsync_end - mode->hsync_start; + timing->hbp = mode->htotal - mode->hsync_end; + + timing->y_res = mode->vdisplay; + timing->vfp = mode->vsync_start - mode->vdisplay; + timing->vsw = mode->vsync_end - mode->vsync_start; + timing->vbp = mode->vtotal - mode->vsync_end; +} + +static int samsung_drm_connector_get_modes(struct drm_connector *connector) +{ + struct samsung_drm_connector *samsung_connector; + struct samsung_drm_display *display; + unsigned int count = 0; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_connector = to_samsung_connector(connector); + display = samsung_connector->display; + + /* + * if edid, get edid modes from display device and update it and then + * add its data. + */ + if (display->get_edid) { + void *edid = kzalloc(MAX_EDID, GFP_KERNEL); + if (!edid) { + DRM_ERROR("failed to allocate edid.\n"); + goto fail; + } + + display->get_edid(connector, edid, MAX_EDID); + + drm_mode_connector_update_edid_property(connector, edid); + count = drm_add_edid_modes(connector, edid); + + kfree(connector->display_info.raw_edid); + connector->display_info.raw_edid = edid; + } else { + struct drm_display_mode *mode = drm_mode_create(connector->dev); + struct samsung_video_timings *timing; + + if (display->get_timing) + timing = (struct samsung_video_timings *) + display->get_timing(); + else { + DRM_ERROR("get_timing is null.\n"); + goto fail; + } + + convert_to_display_mode(timing, mode); + + mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; + drm_mode_set_name(mode); + drm_mode_probed_add(connector, mode); + + count = 1; + } + +fail: + return count; +} + +static int samsung_drm_connector_mode_valid(struct drm_connector *connector, + struct drm_display_mode *mode) +{ + struct samsung_drm_connector *samsung_connector; + struct samsung_drm_display *display; + struct samsung_video_timings timing; + int ret = MODE_BAD; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_connector = to_samsung_connector(connector); + display = samsung_connector->display; + + convert_to_video_timing(mode, &timing); + + if (display && display->check_timing) + if (!display->check_timing((void *)&timing)) + ret = MODE_OK; + + return ret; +} + +struct drm_encoder *samsung_drm_best_encoder(struct drm_connector *connector) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + return samsung_drm_get_attached_encoder(connector); +} + +static struct drm_connector_helper_funcs samsung_connector_helper_funcs = { + .get_modes = samsung_drm_connector_get_modes, + .mode_valid = samsung_drm_connector_mode_valid, + .best_encoder = samsung_drm_best_encoder, +}; + +/* get detection status of display device. */ +static enum drm_connector_status + samsung_drm_connector_detect(struct drm_connector *connector, + bool force) +{ + struct drm_encoder *encoder; + struct samsung_drm_connector *samsung_connector; + struct samsung_drm_display *display; + struct samsung_drm_manager *manager; + unsigned int ret = connector_status_unknown; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_connector = to_samsung_connector(connector); + display = samsung_connector->display; + + /* get drm_encoder object connected to this drm_connector. */ + encoder = samsung_drm_get_attached_encoder(connector); + if (!encoder) { + DRM_ERROR("encoder connected to connector is null.\n"); + return ret; + } + + manager = samsung_drm_get_manager(encoder); + if (!manager) { + DRM_ERROR("manager of encoder is null.\n"); + return ret; + } + + if (display->is_connected) { + if (display->is_connected()) + ret = connector_status_connected; + else + ret = connector_status_disconnected; + } + + return ret; +} + +static void samsung_drm_connector_destroy(struct drm_connector *connector) +{ + struct samsung_drm_connector *samsung_connector = + to_samsung_connector(connector); + + DRM_DEBUG_KMS("%s\n", __FILE__); + + drm_sysfs_connector_remove(connector); + drm_connector_cleanup(connector); + kfree(samsung_connector); +} + +static struct drm_connector_funcs samsung_connector_funcs = { + .dpms = drm_helper_connector_dpms, + .fill_modes = drm_helper_probe_single_connector_modes, + .detect = samsung_drm_connector_detect, + .destroy = samsung_drm_connector_destroy, +}; + +static int get_connector_type(struct samsung_drm_manager *manager) +{ + int type = -EINVAL; + + switch (manager->display_type) { + case SAMSUNG_DISPLAY_TYPE_HDMI: + type = DRM_MODE_CONNECTOR_HDMIA; + break; + default: + type = DRM_MODE_CONNECTOR_Unknown; + break; + } + + return type; +} + +int samsung_drm_connector_create(struct drm_device *dev, + struct drm_encoder *encoder) +{ + struct samsung_drm_connector *samsung_connector; + struct samsung_drm_manager *manager = samsung_drm_get_manager(encoder); + struct samsung_drm_display *display; + struct drm_connector *connector; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_connector = kzalloc(sizeof(*samsung_connector), + GFP_KERNEL); + if (!samsung_connector) { + DRM_ERROR("failed to allocate connector.\n"); + return -ENOMEM; + } + + /** + * get display device driver obejct according to display type. + * we can control display device through this object. + */ + if (!manager->ops->get_display) { + DRM_ERROR("get_display is null.\n"); + return -EFAULT; + } + + display = manager->ops->get_display(manager->subdrv_dev); + if (!display) { + DRM_ERROR("failed to get display device.\n"); + return -EFAULT; + } + + samsung_connector->display = display; + connector = &samsung_connector->drm_connector; + + ret = get_connector_type(manager); + if (ret < 0) { + DRM_ERROR("wrong display type.\n"); + goto out; + } + + drm_connector_init(dev, connector, + &samsung_connector_funcs, ret); + drm_connector_helper_add(connector, + &samsung_connector_helper_funcs); + + ret = drm_sysfs_connector_add(connector); + if (ret < 0) + goto out; + + ret = drm_mode_connector_attach_encoder(connector, encoder); + if (ret < 0) { + DRM_ERROR("failed to attach a connector to a encoder.\n"); + goto out; + } + + DRM_DEBUG_KMS("connector has been created.\n"); + +out: + return ret; +} + +struct drm_encoder * + samsung_drm_get_attached_encoder(struct drm_connector *connector) +{ + int i; + struct samsung_drm_connector *samsung_connector; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_connector = to_samsung_connector(connector); + + for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { + struct drm_mode_object *obj; + + if (connector->encoder_ids[i] == 0) { + DRM_ERROR("there is no drm_encoder registered.\n"); + return NULL; + } + + obj = drm_mode_object_find(connector->dev, + connector->encoder_ids[i], + DRM_MODE_OBJECT_ENCODER); + + if (!obj) { + DRM_ERROR("drm_mode_object of encoder_ids is null.\n"); + return NULL; + } + + return obj_to_encoder(obj); + } + + return NULL; +} + +struct samsung_drm_display * + get_display_from_connector(struct drm_connector *connector) { + + struct samsung_drm_connector *samsung_connector; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_connector = to_samsung_connector(connector); + + return samsung_connector->display; +} + +MODULE_AUTHOR("Inki Dae <inki.dae(a)samsung.com>"); +MODULE_DESCRIPTION("Samsung SoC DRM Connector Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/samsung/samsung_drm_connector.h b/drivers/gpu/drm/samsung/samsung_drm_connector.h new file mode 100644 index 0000000..ed7be57 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_connector.h @@ -0,0 +1,39 @@ +/* samsung_drm_connector.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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 _SAMSUNG_DRM_CONNECTOR_H_ +#define _SAMSUNG_DRM_CONNECTOR_H_ + + /* initialize connector. (drm and samsung SoC specific connector) */ +int samsung_drm_connector_create(struct drm_device *dev, + struct drm_encoder *encoder); + +/* get an encoder attached to an connector. */ +struct drm_encoder * + samsung_drm_get_attached_encoder(struct drm_connector *connector); + +#endif diff --git a/drivers/gpu/drm/samsung/samsung_drm_crtc.c b/drivers/gpu/drm/samsung/samsung_drm_crtc.c new file mode 100644 index 0000000..4663a8a --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_crtc.c @@ -0,0 +1,304 @@ +/* samsung_drm_crtc.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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_crtc_helper.h" + +#include <drm/samsung_drm.h> + +#include "samsung_drm_common.h" +#include "samsung_drm_fb.h" +#include "samsung_drm_crtc.h" + +#define to_samsung_crtc(x) container_of(x, struct samsung_drm_crtc,\ + drm_crtc) + +struct samsung_drm_crtc { + struct drm_crtc drm_crtc; + struct samsung_drm_overlay *overlay; +}; + +static int samsung_drm_overlay_update(struct samsung_drm_overlay *overlay, + struct drm_framebuffer *fb, + struct drm_display_mode *mode, + struct samsung_drm_crtc_pos *pos) +{ + struct samsung_drm_buffer_info buffer_info; + unsigned int bpp; + unsigned int actual_w = pos->crtc_w; + unsigned int actual_h = pos->crtc_h; + unsigned int hw_w; + unsigned int hw_h; + int ret; + + /* update buffer address of framebuffer. */ + ret = samsung_drm_fb_update_buf_off(fb, pos->fb_x, pos->fb_y, + &buffer_info); + if (ret < 0) { + DRM_ERROR("failed to update framebuffer offset\n"); + return ret; + } + + /* set start position of framebuffer memory to be displayed. */ + overlay->paddr = buffer_info.paddr; + overlay->vaddr = buffer_info.vaddr; + + hw_w = mode->hdisplay - pos->base_x; + hw_h = mode->vdisplay - pos->base_y; + + if (actual_w > hw_w) + actual_w = hw_w; + if (actual_h > hw_h) + actual_h = hw_h; + + overlay->offset_x = pos->base_x; + overlay->offset_y = pos->base_y; + overlay->width = actual_w; + overlay->height = actual_h; + + DRM_DEBUG_KMS("overlay : offset_x/y(%d,%d), width/height(%d,%d)", + overlay->offset_x, overlay->offset_y, + overlay->width, overlay->height); + + bpp = (overlay->bpp >> 3); + + overlay->buf_offsize = (fb->width - actual_w) * bpp; + overlay->line_size = actual_w * bpp; + overlay->end_buf_off = fb->width * actual_h * bpp; + + return 0; +} + +static int samsung_drm_crtc_update(struct drm_crtc *crtc) +{ + struct samsung_drm_crtc *samsung_crtc; + struct samsung_drm_overlay *overlay; + struct samsung_drm_crtc_pos pos; + struct drm_display_mode *mode = &crtc->mode; + struct drm_framebuffer *fb = crtc->fb; + + if (!mode || !fb) + return -EINVAL; + + samsung_crtc = to_samsung_crtc(crtc); + overlay = samsung_crtc->overlay; + + memset(&pos, 0, sizeof(struct samsung_drm_crtc_pos)); + pos.fb_x = crtc->x; + pos.fb_y = crtc->y; + pos.crtc_w = fb->width - crtc->x; + pos.crtc_h = fb->height - crtc->y; + + return samsung_drm_overlay_update(overlay, crtc->fb, mode, &pos); +} + +/* CRTC helper functions */ +static void samsung_drm_crtc_dpms(struct drm_crtc *crtc, int mode) +{ + /* TODO */ + DRM_DEBUG_KMS("%s\n", __FILE__); +} + +static void samsung_drm_crtc_prepare(struct drm_crtc *crtc) +{ + /* TODO */ + DRM_DEBUG_KMS("%s\n", __FILE__); +} + +static void samsung_drm_crtc_commit(struct drm_crtc *crtc) +{ + struct samsung_drm_crtc *samsung_crtc = to_samsung_crtc(crtc); + struct samsung_drm_overlay *overlay = samsung_crtc->overlay; + struct samsung_drm_overlay_ops *overlay_ops = overlay->ops; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + overlay_ops->commit(overlay->subdrv_dev, overlay->win_num); +} + +static bool samsung_drm_crtc_mode_fixup(struct drm_crtc *crtc, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + /* drm framework doesn't check NULL. */ + + return true; +} + +/* change mode and update overlay. */ +static int samsung_drm_crtc_mode_set(struct drm_crtc *crtc, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode, int x, int y, + struct drm_framebuffer *old_fb) +{ + struct samsung_drm_crtc *samsung_crtc = to_samsung_crtc(crtc); + struct samsung_drm_overlay *overlay = samsung_crtc->overlay; + struct samsung_drm_overlay_ops *overlay_ops = overlay->ops; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + mode = adjusted_mode; + + ret = samsung_drm_crtc_update(crtc); + if (ret < 0) + return ret; + + overlay_ops->mode_set(overlay->subdrv_dev, overlay); + + return ret; +} + +static int samsung_drm_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y, + struct drm_framebuffer *old_fb) +{ + struct samsung_drm_crtc *samsung_crtc = to_samsung_crtc(crtc); + struct samsung_drm_overlay *overlay = samsung_crtc->overlay; + struct samsung_drm_overlay_ops *overlay_ops = overlay->ops; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + ret = samsung_drm_crtc_update(crtc); + if (ret < 0) + return ret; + + overlay_ops->mode_set(overlay->subdrv_dev, overlay); + overlay_ops->commit(overlay->subdrv_dev, overlay->win_num); + + return ret; +} + +static void samsung_drm_crtc_load_lut(struct drm_crtc *crtc) +{ + /* drm framework doesn't check NULL. */ + + DRM_DEBUG_KMS("%s\n", __FILE__); +} + +static struct drm_crtc_helper_funcs samsung_crtc_helper_funcs = { + .dpms = samsung_drm_crtc_dpms, + .prepare = samsung_drm_crtc_prepare, + .commit = samsung_drm_crtc_commit, + .mode_fixup = samsung_drm_crtc_mode_fixup, + .mode_set = samsung_drm_crtc_mode_set, + .mode_set_base = samsung_drm_crtc_mode_set_base, + .load_lut = samsung_drm_crtc_load_lut, +}; + +/* CRTC functions */ +static int samsung_drm_crtc_page_flip(struct drm_crtc *crtc, + struct drm_framebuffer *fb, + struct drm_pending_vblank_event *event) +{ + struct drm_device *dev = crtc->dev; + struct samsung_drm_private *dev_priv = dev->dev_private; + struct samsung_drm_crtc *samsung_crtc = to_samsung_crtc(crtc); + struct samsung_drm_overlay *overlay = samsung_crtc->overlay; + struct samsung_drm_overlay_ops *overlay_ops = overlay->ops; + struct drm_framebuffer *old_fb = crtc->fb; + int ret; + + if (event && !dev_priv->pageflip_event) { + list_add_tail(&event->base.link, + &dev_priv->pageflip_event_list); + /* FIXME: CRTC */ + ret = drm_vblank_get(dev, 0); + if (ret) { + DRM_DEBUG("failed to acquire vblank counter\n"); + return ret; + } + dev_priv->pageflip_event = true; + } + + crtc->fb = fb; + + ret = samsung_drm_crtc_update(crtc); + if (ret < 0) { + crtc->fb = old_fb; + if (event && dev_priv->pageflip_event) { + /* FIXME: CRTC */ + drm_vblank_put(dev, 0); + dev_priv->pageflip_event = false; + } + return ret; + } + + overlay_ops->mode_set(overlay->subdrv_dev, overlay); + overlay_ops->commit(overlay->subdrv_dev, overlay->win_num); + + return 0; +} + +static void samsung_drm_crtc_destroy(struct drm_crtc *crtc) +{ + struct samsung_drm_crtc *samsung_crtc = to_samsung_crtc(crtc); + + DRM_DEBUG_KMS("%s\n", __FILE__); + + drm_crtc_cleanup(crtc); + kfree(samsung_crtc->overlay); + kfree(samsung_crtc); +} + +static struct drm_crtc_funcs samsung_crtc_funcs = { + .set_config = drm_crtc_helper_set_config, + .page_flip = samsung_drm_crtc_page_flip, + .destroy = samsung_drm_crtc_destroy, +}; + +int samsung_drm_crtc_create(struct drm_device *dev, + struct samsung_drm_overlay *overlay) +{ + struct samsung_drm_crtc *samsung_crtc; + struct drm_crtc *crtc; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + if (!overlay) + return -EINVAL; + + samsung_crtc = kzalloc(sizeof(*samsung_crtc), GFP_KERNEL); + if (!samsung_crtc) { + DRM_ERROR("failed to allocate samsung crtc\n"); + return -ENOMEM; + } + + samsung_crtc->overlay = overlay; + crtc = &samsung_crtc->drm_crtc; + + drm_crtc_init(dev, crtc, &samsung_crtc_funcs); + drm_crtc_helper_add(crtc, &samsung_crtc_helper_funcs); + + /* TODO: multi overlay */ + + return 0; +} + +MODULE_AUTHOR("Inki Dae <inki.dae(a)samsung.com>"); +MODULE_DESCRIPTION("Samsung SoC DRM CRTC Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/samsung/samsung_drm_crtc.h b/drivers/gpu/drm/samsung/samsung_drm_crtc.h new file mode 100644 index 0000000..fff7593 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_crtc.h @@ -0,0 +1,50 @@ +/* samsung_drm_crtc.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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 _SAMSUNG_DRM_CRTC_H_ +#define _SAMSUNG_DRM_CRTC_H_ + +/* + * @fb_x: horizontal position from framebuffer base + * @fb_y: vertical position from framebuffer base + * @base_x: horizontal position from screen base + * @base_y: vertical position from screen base + * @crtc_w: width of crtc + * @crtc_h: height of crtc + */ +struct samsung_drm_crtc_pos { + unsigned int fb_x; + unsigned int fb_y; + unsigned int base_x; + unsigned int base_y; + unsigned int crtc_w; + unsigned int crtc_h; +}; + +int samsung_drm_crtc_create(struct drm_device *dev, + struct samsung_drm_overlay *overlay); +#endif diff --git a/drivers/gpu/drm/samsung/samsung_drm_drv.c b/drivers/gpu/drm/samsung/samsung_drm_drv.c new file mode 100644 index 0000000..f8ab05f --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_drv.c @@ -0,0 +1,384 @@ +/* samsung_drm_drv.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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 "samsung_drm.h" + +#include "samsung_drm_encoder.h" +#include "samsung_drm_connector.h" +#include "samsung_drm_crtc.h" +#include "samsung_drm_fbdev.h" +#include "samsung_drm_fb.h" +#include "samsung_drm_gem.h" +#include "samsung_drm_buf.h" + +#include <drm/samsung_drm.h> +#include <plat/samsung_drm.h> + +#define DRIVER_NAME "samsung-drm" +#define DRIVER_DESC "Samsung SoC DRM" +#define DRIVER_DATE "20110530" +#define DRIVER_MAJOR 1 +#define DRIVER_MINOR 0 + +static DEFINE_MUTEX(drv_mutex); +static LIST_HEAD(subdrv_list); + +void samsung_drm_subdrv_register(struct samsung_drm_subdrv *subdrv) +{ + mutex_lock(&drv_mutex); + list_add_tail(&subdrv->list, &subdrv_list); + mutex_unlock(&drv_mutex); +} +EXPORT_SYMBOL(samsung_drm_subdrv_register); + +void samsung_drm_subdrv_unregister(struct samsung_drm_subdrv *subdrv) +{ + mutex_lock(&drv_mutex); + list_del(&subdrv->list); + mutex_unlock(&drv_mutex); +} +EXPORT_SYMBOL(samsung_drm_subdrv_unregister); + +static struct drm_mode_config_funcs samsung_drm_mode_config_funcs = { + .fb_create = samsung_drm_fb_create, +}; + +static int __samsung_drm_mode_init(struct drm_device *dev, + struct samsung_drm_subdrv *subdrv) +{ + struct samsung_drm_overlay *overlay; + struct samsung_drm_manager *manager; + struct samsung_drm_subdrv_data *subdrv_data; + struct drm_encoder *encoder; + int ret; + + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + if (!subdrv) + return -EINVAL; + + subdrv_data = subdrv->data; + + overlay = kzalloc(sizeof(*overlay), GFP_KERNEL); + manager = kzalloc(sizeof(*manager), GFP_KERNEL); + + if (!overlay || !manager) { + DRM_ERROR("failed to allocate\n"); + ret = -ENOMEM; + goto err_alloc; + } + + overlay->win_num = subdrv_data->overlay_num; + overlay->bpp = subdrv_data->bpp; + overlay->ops = subdrv->overlay_ops; + overlay->subdrv_dev = subdrv->dev; + + manager->display_type = subdrv_data->display_type; + manager->ops = subdrv->manager_ops; + manager->subdrv_dev = subdrv->dev; + + /* initialize encoder. */ + encoder = samsung_drm_encoder_create(dev, manager); + if (!encoder) { + DRM_ERROR("failed to create encoder\n"); + ret = -EFAULT; + goto err_alloc; + } + + /* initialize connector. */ + ret = samsung_drm_connector_create(dev, encoder); + if (ret) { + DRM_ERROR("failed to create connector\n"); + goto err; + } + + /* initialize crtc. */ + ret = samsung_drm_crtc_create(dev, overlay); + if (ret) { + DRM_ERROR("failed to create crtc\n"); + goto err; + } + + DRM_DEBUG_KMS("completed mode initialization\n"); + + return 0; + +err: + drm_mode_config_cleanup(dev); +err_alloc: + kfree(overlay); + kfree(manager); + return ret; +} + +static void samsung_drm_mode_init(struct drm_device *dev) +{ + struct samsung_drm_subdrv *subdrv; + int err; + + list_for_each_entry(subdrv, &subdrv_list, list) { + /* probe subdrv drivers registered to drm */ + if (subdrv->probe) { + err = subdrv->probe(dev); + if (err) + goto err_handle; + } + + err = __samsung_drm_mode_init(dev, subdrv); + if (err) { + if (subdrv->remove) + subdrv->remove(dev); + goto err_handle; + } + continue; + +err_handle: + samsung_drm_subdrv_unregister(subdrv); + } +} + +static void __samsung_drm_mode_cleanup(struct drm_device *dev, + struct samsung_drm_subdrv *subdrv) +{ + /* do nothing yet */ +} + +static void samsung_drm_mode_cleanup(struct drm_device *dev) +{ + struct samsung_drm_subdrv *subdrv; + + list_for_each_entry(subdrv, &subdrv_list, list) { + __samsung_drm_mode_cleanup(dev, subdrv); + + if (subdrv->remove) + subdrv->remove(dev); + } +} + +static int samsung_drm_load(struct drm_device *dev, unsigned long flags) +{ + struct samsung_drm_private *private; + int ret; + + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + private = kzalloc(sizeof(struct samsung_drm_private), GFP_KERNEL); + if (!private) { + DRM_ERROR("failed to allocate samsung_drm_private.\n"); + return -ENOMEM; + } + + INIT_LIST_HEAD(&private->pageflip_event_list); + dev->dev_private = (void *)private; + + drm_mode_config_init(dev); + + dev->mode_config.min_width = 0; + dev->mode_config.min_height = 0; + + /* + * It sets max width and height as default value(4096x4096). + * this value would be used to check for framebuffer size limitation + * at drm_mode_addfb(). + */ + dev->mode_config.max_width = 4096; + dev->mode_config.max_height = 4096; + + dev->mode_config.funcs = &samsung_drm_mode_config_funcs; + + samsung_drm_mode_init(dev); + + ret = samsung_drm_fbdev_init(dev); + if (ret < 0) { + DRM_ERROR("failed to initialize drm fbdev.\n"); + goto err_subdrv; + } + + ret = drm_vblank_init(dev, private->num_crtc); + if (ret) + goto err_fbdev; + + return 0; + +err_fbdev: + samsung_drm_fbdev_fini(dev); +err_subdrv: + samsung_drm_mode_cleanup(dev); + drm_mode_config_cleanup(dev); + kfree(private); + + return ret; +} + +static int samsung_drm_unload(struct drm_device *dev) +{ + drm_vblank_cleanup(dev); + samsung_drm_fbdev_fini(dev); + samsung_drm_mode_cleanup(dev); + drm_mode_config_cleanup(dev); + kfree(dev->dev_private); + + return 0; +} + +static int samsung_drm_open(struct drm_device *dev, struct drm_file *file_priv) +{ + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + return 0; +} + +static void samsung_drm_lastclose(struct drm_device *dev) +{ + samsung_drm_fbdev_restore_mode(dev); +} + +static int samsung_drm_master_create(struct drm_device *dev, + struct drm_master *master) +{ + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + /* TODO. */ + master->driver_priv = NULL; + + return 0; +} + +static int samsung_drm_master_set(struct drm_device *dev, + struct drm_file *file_priv, bool from_open) +{ + struct drm_master *master = file_priv->master; + + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + master->lock.hw_lock = kzalloc(sizeof(struct drm_hw_lock), GFP_KERNEL); + if (!master->lock.hw_lock) { + DRM_DEBUG("failed to allocate drm_hw_lock.\n"); + return -ENOMEM; + } + + return 0; +} + +static struct vm_operations_struct samsung_drm_gem_vm_ops = { + .fault = samsung_drm_gem_fault, + .open = drm_gem_vm_open, + .close = drm_gem_vm_close, +}; + +static struct drm_ioctl_desc samsung_ioctls[] = { + DRM_IOCTL_DEF_DRV(SAMSUNG_GEM_CREATE, samsung_drm_gem_create_ioctl, + DRM_UNLOCKED), + DRM_IOCTL_DEF_DRV(SAMSUNG_GEM_MAP_OFFSET, + samsung_drm_gem_map_offset_ioctl, DRM_UNLOCKED), + DRM_IOCTL_DEF_DRV(SAMSUNG_GEM_MMAP, + samsung_drm_gem_mmap_ioctl, DRM_UNLOCKED), +}; + +static struct drm_driver samsung_drm_driver = { + .driver_features = DRIVER_HAVE_IRQ | DRIVER_BUS_PLATFORM | + DRIVER_MODESET | DRIVER_GEM, + .load = samsung_drm_load, + .unload = samsung_drm_unload, + .open = samsung_drm_open, + .firstopen = NULL, + .lastclose = samsung_drm_lastclose, + .preclose = NULL, + .postclose = NULL, + .get_vblank_counter = drm_vblank_count, + .master_create = samsung_drm_master_create, + .master_set = samsung_drm_master_set, + .gem_init_object = samsung_drm_gem_init_object, + .gem_free_object = samsung_drm_gem_free_object, + .gem_vm_ops = &samsung_drm_gem_vm_ops, + .dumb_create = samsung_drm_gem_dumb_create, + .dumb_map_offset = samsung_drm_gem_dumb_map_offset, + .dumb_destroy = samsung_drm_gem_dumb_destroy, + .ioctls = samsung_ioctls, + .fops = { + .owner = THIS_MODULE, + .open = drm_open, + .mmap = samsung_drm_gem_mmap, + .poll = drm_poll, + .read = drm_read, + .unlocked_ioctl = drm_ioctl, + .release = drm_release, + }, + .name = DRIVER_NAME, + .desc = DRIVER_DESC, + .date = DRIVER_DATE, + .major = DRIVER_MAJOR, + .minor = DRIVER_MINOR, +}; + +static int samsung_drm_platform_probe(struct platform_device *pdev) +{ + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + samsung_drm_driver.num_ioctls = DRM_ARRAY_SIZE(samsung_ioctls); + + return drm_platform_init(&samsung_drm_driver, pdev); +} + +static int samsung_drm_platform_remove(struct platform_device *pdev) +{ + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + drm_platform_exit(&samsung_drm_driver, pdev); + + return 0; +} + +static struct platform_driver samsung_drm_platform_driver = { + .probe = samsung_drm_platform_probe, + .remove = __devexit_p(samsung_drm_platform_remove), + .driver = { + .owner = THIS_MODULE, + .name = DRIVER_NAME, + }, +}; + +static int __init samsung_drm_init(void) +{ + DRM_DEBUG_DRIVER("%s\n", __FILE__); + + return platform_driver_register(&samsung_drm_platform_driver); +} + +static void __exit samsung_drm_exit(void) +{ + platform_driver_unregister(&samsung_drm_platform_driver); +} + +module_init(samsung_drm_init); +module_exit(samsung_drm_exit); + +MODULE_AUTHOR("Inki Dae <inki.dae(a)samsung.com>"); +MODULE_DESCRIPTION("Samsung SoC DRM Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/samsung/samsung_drm_encoder.c b/drivers/gpu/drm/samsung/samsung_drm_encoder.c new file mode 100644 index 0000000..86c4c5c --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_encoder.c @@ -0,0 +1,233 @@ +/* samsung_drm_encoder.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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_crtc_helper.h" + +#include "samsung_drm_common.h" + +#include <drm/samsung_drm.h> + +#define to_samsung_encoder(x) container_of(x, struct samsung_drm_encoder,\ + drm_encoder) + +struct samsung_drm_encoder { + struct drm_encoder drm_encoder; + struct samsung_drm_manager *mgr; +}; + +static void samsung_drm_encoder_dpms(struct drm_encoder *encoder, int mode) +{ + struct drm_device *dev = encoder->dev; + struct drm_connector *connector; + struct samsung_drm_manager *mgr; + + DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode); + + mgr = samsung_drm_get_manager(encoder); + if (!mgr) { + DRM_ERROR("manager is NULL.\n"); + return; + } + + list_for_each_entry(connector, &dev->mode_config.connector_list, + head) { + if (connector->encoder == encoder) { + struct samsung_drm_display *display; + + display = get_display_from_connector(connector); + + if (display && display->power_on) + display->power_on(mode); + } + } +} + +static bool samsung_drm_encoder_mode_fixup(struct drm_encoder *encoder, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + return true; +} + +static void samsung_drm_encoder_mode_set(struct drm_encoder *encoder, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + struct drm_device *dev = encoder->dev; + struct drm_connector *connector; + struct samsung_drm_manager *mgr; + struct samsung_drm_manager_ops *manager_ops; + + mode = adjusted_mode; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + mgr = samsung_drm_get_manager(encoder); + if (!mgr) { + DRM_ERROR("manager is NULL.\n"); + return; + } + + manager_ops = mgr->ops; + if (!manager_ops) { + DRM_ERROR("ops of mgr is null.\n"); + return; + } + + list_for_each_entry(connector, &dev->mode_config.connector_list, + head) { + if (connector->encoder == encoder) + if (manager_ops && manager_ops->mode_set) + manager_ops->mode_set(mgr->subdrv_dev, mode); + } +} + +static void samsung_drm_encoder_prepare(struct drm_encoder *encoder) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + /* TODO. */ +} + +static void samsung_drm_encoder_commit(struct drm_encoder *encoder) +{ + struct samsung_drm_manager *mgr; + struct samsung_drm_manager_ops *manager_ops; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + mgr = samsung_drm_get_manager(encoder); + if (!mgr) { + DRM_ERROR("manager is NULL.\n"); + return; + } + + manager_ops = mgr->ops; + if (!manager_ops) { + DRM_ERROR("ops of mgr is null.\n"); + return; + } + + if (manager_ops && manager_ops->commit) + manager_ops->commit(mgr->subdrv_dev); +} + +static struct drm_crtc * + samsung_drm_encoder_get_crtc(struct drm_encoder *encoder) +{ + return encoder->crtc; +} + +static struct drm_encoder_helper_funcs samsung_encoder_helper_funcs = { + .dpms = samsung_drm_encoder_dpms, + .mode_fixup = samsung_drm_encoder_mode_fixup, + .mode_set = samsung_drm_encoder_mode_set, + .prepare = samsung_drm_encoder_prepare, + .commit = samsung_drm_encoder_commit, + .get_crtc = samsung_drm_encoder_get_crtc, +}; + +static void samsung_drm_encoder_destroy(struct drm_encoder *encoder) +{ + struct samsung_drm_encoder *samsung_encoder = + to_samsung_encoder(encoder); + + DRM_DEBUG_KMS("%s\n", __FILE__); + + drm_encoder_cleanup(encoder); + kfree(samsung_encoder->mgr); + kfree(samsung_encoder); +} + +static struct drm_encoder_funcs samsung_encoder_funcs = { + .destroy = samsung_drm_encoder_destroy, +}; + +/** + * initialize encoder. (drm and samsung SoC specific encoder) + * + * @dev: object of struct drm_device + */ +struct drm_encoder *samsung_drm_encoder_create(struct drm_device *dev, + struct samsung_drm_manager *mgr) +{ + struct samsung_drm_private *private = dev->dev_private; + struct drm_encoder *encoder; + struct samsung_drm_encoder *samsung_encoder; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_encoder = kzalloc(sizeof(*samsung_encoder), GFP_KERNEL); + if (!samsung_encoder) { + DRM_ERROR("failed to allocate encoder.\n"); + return NULL; + } + + samsung_encoder->mgr = mgr; + encoder = &samsung_encoder->drm_encoder; + + BUG_ON(!private->num_crtc); + + encoder->possible_crtcs = 0x1 << (private->num_crtc - 1); + + DRM_DEBUG_KMS("num_crtc = %d, possible_crtcs = 0x%x\n", + private->num_crtc, encoder->possible_crtcs); + + /* add to encoder list. */ + drm_encoder_init(dev, encoder, &samsung_encoder_funcs, + DRM_MODE_ENCODER_TMDS); + + /* set encoder helper callbacks. */ + drm_encoder_helper_add(encoder, &samsung_encoder_helper_funcs); + + DRM_DEBUG_KMS("encoder has been created.\n"); + + return encoder; +} + +struct samsung_drm_manager *samsung_drm_get_manager(struct drm_encoder *encoder) +{ + struct samsung_drm_encoder *samsung_encoder; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_encoder = container_of(encoder, struct samsung_drm_encoder, + drm_encoder); + if (!samsung_encoder) { + DRM_ERROR("samsung_encoder is null.\n"); + return NULL; + } + + return samsung_encoder->mgr; +} + +MODULE_AUTHOR("Inki Dae <inki.dae(a)samsung.com>"); +MODULE_DESCRIPTION("Samsung SoC DRM Encoder Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/samsung/samsung_drm_encoder.h b/drivers/gpu/drm/samsung/samsung_drm_encoder.h new file mode 100644 index 0000000..31c19dd --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_encoder.h @@ -0,0 +1,37 @@ +/* samsung_drm_encoder.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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 _SAMSUNG_DRM_ENCODER_H_ +#define _SAMSUNG_DRM_ENCODER_H_ + +struct samsung_drm_manager; + + /* initialize encoder. (drm and samsung SoC specific encoder) */ +struct drm_encoder *samsung_drm_encoder_create(struct drm_device *dev, + struct samsung_drm_manager *mgr); + +#endif diff --git a/drivers/gpu/drm/samsung/samsung_drm_fb.c b/drivers/gpu/drm/samsung/samsung_drm_fb.c new file mode 100644 index 0000000..d539de8 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_fb.c @@ -0,0 +1,288 @@ +/* samsung_drm_fb.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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_crtc.h" +#include "drm_crtc_helper.h" + +#include "samsung_drm_fb.h" +#include "samsung_drm_buf.h" +#include "samsung_drm_gem.h" + +#define to_samsung_drm_framebuffer(x) container_of(x,\ + struct samsung_drm_framebuffer, drm_framebuffer) + +struct samsung_drm_framebuffer { + struct drm_framebuffer drm_framebuffer; + struct drm_file *file_priv; + struct samsung_drm_gem_obj *samsung_gem_obj; + + /* samsung gem object handle. */ + unsigned int gem_handle; + /* unique id to buffer object. */ + unsigned int id; + + unsigned int fb_size; + unsigned long paddr; + void __iomem *vaddr; +}; + +static void samsung_drm_fb_destroy(struct drm_framebuffer *framebuffer) +{ + struct drm_device *dev = framebuffer->dev; + struct samsung_drm_framebuffer *samsung_fb = + to_samsung_drm_framebuffer(framebuffer); + struct samsung_drm_gem_obj *samsung_gem_obj; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + /** + * revert drm framebuffer to old one and remove drm framebuffer object. + * - this callback would be called when uer application is released. + * drm_release() -> drm_fb_release() -> fb->func->destroy() + */ + + /** + * release drm_framebuffer from idr table and + * call crtc->funcs->set_config() callback + * to change current framebuffer to old one. + */ + drm_framebuffer_cleanup(framebuffer); + + /** + * find buffer object registered. + * + * if samsung_fb->gem_handle is 0, then this means + * that the memory region for drm framebuffer was allocated + * without using gem interface. + */ + samsung_gem_obj = find_samsung_drm_gem_object(samsung_fb->file_priv, + dev, samsung_fb->gem_handle); + if (!samsung_gem_obj) { + DRM_DEBUG_KMS("this gem object has already been released.\n"); + + if (samsung_fb->samsung_gem_obj && !samsung_fb->gem_handle) { + samsung_gem_obj = samsung_fb->samsung_gem_obj; + DRM_DEBUG_KMS("so release buffer without using gem.\n"); + } else + goto out; + } + + ret = drm_gem_handle_delete(samsung_fb->file_priv, + samsung_fb->gem_handle); + if (ret < 0) { + DRM_ERROR("failed to delete drm_gem_handle.\n"); + goto out; + } + + /* release framebuffer memory region. */ + ret = samsung_drm_buf_destroy(dev, samsung_gem_obj); + if (ret < 0) + DRM_DEBUG_KMS("failed to release this buffer.\n"); + +out: + kfree(samsung_fb); +} + +static int samsung_drm_fb_create_handle(struct drm_framebuffer *fb, + struct drm_file *file_priv, unsigned int *handle) +{ + struct samsung_drm_framebuffer *samsung_fb = + to_samsung_drm_framebuffer(fb); + + DRM_DEBUG_KMS("%s\n", __FILE__); + + /** + * set buffer handle of this framebuffer to *handle. + * - this callback would be called by user application + * with DRM_IOCTL_MODE_GETFB command. + */ + + if (!samsung_fb->gem_handle) { + DRM_ERROR("can't get id to buffer object.\n"); + return -EINVAL; + } + + *handle = samsung_fb->gem_handle; + + DRM_DEBUG_KMS("got buffer object id(%d)\n", *handle); + + return 0; +} + +static int samsung_drm_fb_dirty(struct drm_framebuffer *framebuffer, + struct drm_file *file_priv, unsigned flags, + unsigned color, struct drm_clip_rect *clips, + unsigned num_clips) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + /** + * update framebuffer and its hardware. + * - this callback would be called by user application + * with DRM_IOCTL_MODE_DIRTYFB command. + * + * ps. Userspace can notify the driver via this callback + * that an area of the framebuffer has been changed then should + * be flushed to the display hardware. + */ + + return 0; +} + +static struct drm_framebuffer_funcs samsung_drm_fb_funcs = { + .destroy = samsung_drm_fb_destroy, + .create_handle = samsung_drm_fb_create_handle, + .dirty = samsung_drm_fb_dirty, +}; + +struct drm_framebuffer *samsung_drm_fb_create(struct drm_device *dev, + struct drm_file *file_priv, struct drm_mode_fb_cmd *mode_cmd) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + /** + * create new drm framebuffer. + * - this callback would be called by user application + * with DRM_IOCTL_MODE_ADDFB command. + */ + + return samsung_drm_fb_init(file_priv, dev, mode_cmd); +} + +struct drm_framebuffer *samsung_drm_fb_init(struct drm_file *file_priv, + struct drm_device *dev, struct drm_mode_fb_cmd *mode_cmd) +{ + struct samsung_drm_framebuffer *samsung_fb; + struct drm_framebuffer *fb; + struct samsung_drm_gem_obj *samsung_gem_obj; + unsigned int size, gem_handle = 0; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + mode_cmd->pitch = max(mode_cmd->pitch, mode_cmd->width * + (mode_cmd->bpp >> 3)); + + DRM_LOG_KMS("drm fb create(%dx%d)\n", mode_cmd->width, + mode_cmd->height); + + samsung_fb = kzalloc(sizeof(*samsung_fb), GFP_KERNEL); + if (!samsung_fb) { + DRM_ERROR("failed to allocate samsung drm framebuffer.\n"); + return ERR_PTR(-ENOMEM); + } + + fb = &samsung_fb->drm_framebuffer; + ret = drm_framebuffer_init(dev, fb, &samsung_drm_fb_funcs); + if (ret) { + DRM_ERROR("failed to initialize framebuffer.\n"); + goto fail; + } + + DRM_LOG_KMS("create: fb id: %d\n", fb->base.id); + + size = mode_cmd->pitch * mode_cmd->height; + + /** + * if mode_cmd->handle is NULL, + * it allocates framebuffer memory internally. + * else using allocator defined. + * + * ps. mode_cmd->handle could be pointer to a buffer allocated + * by user application using KMS library. + */ + if (!mode_cmd->handle) { + /** + * allocate framebuffer memory. + * - allocated memory address would be set to vaddr + * and paddr of samsung_drm_framebuffer object. + */ + samsung_gem_obj = samsung_drm_buf_create(dev, size); + if (!samsung_gem_obj) + return ERR_PTR(-ENOMEM); + } else { + /* find buffer object registered. */ + samsung_gem_obj = find_samsung_drm_gem_object(file_priv, dev, + mode_cmd->handle); + if (!samsung_gem_obj) + return ERR_PTR(-EINVAL); + + gem_handle = mode_cmd->handle; + } + + samsung_fb->file_priv = file_priv; + samsung_fb->samsung_gem_obj = samsung_gem_obj; + samsung_fb->gem_handle = gem_handle; + samsung_fb->id = samsung_gem_obj->id; + samsung_fb->fb_size = size; + samsung_fb->vaddr = samsung_gem_obj->entry->vaddr; + samsung_fb->paddr = samsung_gem_obj->entry->paddr; + + DRM_DEBUG_KMS("handle = 0x%x, id = %d\n", + samsung_gem_obj->handle, samsung_gem_obj->id); + DRM_DEBUG_KMS("fb: size = 0x%x, vaddr = 0x%x, paddr = 0x%x\n", + samsung_fb->fb_size, (unsigned int)samsung_fb->vaddr, + (unsigned int)samsung_fb->paddr); + + drm_helper_mode_fill_fb_struct(fb, mode_cmd); + + return fb; + +fail: + kfree(samsung_fb); + + return ERR_PTR(ret); +} + +int samsung_drm_fb_update_buf_off(struct drm_framebuffer *fb, + unsigned int x, unsigned int y, + struct samsung_drm_buffer_info *buffer_info) +{ + unsigned int bpp = fb->bits_per_pixel >> 3; + unsigned long offset; + struct samsung_drm_framebuffer *samsung_fb; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_fb = to_samsung_drm_framebuffer(fb); + + offset = (x * bpp) + (y * fb->pitch); + + DRM_DEBUG_KMS("offset(0x%x) = (x(%d) * bpp(%d) + (y(%d) * pitch(%d)\n", + (unsigned int)offset, x, bpp, y, fb->pitch); + + buffer_info->vaddr = samsung_fb->vaddr + offset; + buffer_info->paddr = samsung_fb->paddr + offset; + + DRM_DEBUG_KMS("updated vaddr = 0x%x, paddr = 0x%x\n", + (unsigned int)buffer_info->vaddr, + (unsigned int)buffer_info->paddr); + + return 0; +} diff --git a/drivers/gpu/drm/samsung/samsung_drm_fb.h b/drivers/gpu/drm/samsung/samsung_drm_fb.h new file mode 100644 index 0000000..de92f0d --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_fb.h @@ -0,0 +1,46 @@ +/* samsung_drm_fb.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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 _SAMSUNG_DRM_FB_H_ +#define _SAMSUNG_DRM_FB_H + +struct samsung_drm_buffer_info { + unsigned long paddr; + void __iomem *vaddr; +}; + +int samsung_drm_fb_update_buf_off(struct drm_framebuffer *fb, + unsigned int x, unsigned int y, + struct samsung_drm_buffer_info *buffer_info); + +struct drm_framebuffer *samsung_drm_fb_init(struct drm_file *file_priv, + struct drm_device *dev, struct drm_mode_fb_cmd *mode_cmd); + +struct drm_framebuffer *samsung_drm_fb_create(struct drm_device *dev, + struct drm_file *file_priv, struct drm_mode_fb_cmd *mode_cmd); + +#endif diff --git a/drivers/gpu/drm/samsung/samsung_drm_fbdev.c b/drivers/gpu/drm/samsung/samsung_drm_fbdev.c new file mode 100644 index 0000000..938dd4f --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_fbdev.c @@ -0,0 +1,329 @@ +/* samsung_drm_fbdev.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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_crtc.h" +#include "drm_fb_helper.h" +#include "drm_crtc_helper.h" +#include "samsung_drm_fb.h" + +#include <drm/samsung_drm.h> + +#define to_samsung_fbdev_by_helper(x) container_of(x, struct samsung_drm_fbdev,\ + drm_fb_helper) + +struct samsung_drm_fbdev { + struct drm_fb_helper drm_fb_helper; + struct drm_framebuffer *fb; +}; + +static inline unsigned int chan_to_field(unsigned int chan, + struct fb_bitfield *bf) +{ + chan &= 0xffff; + chan >>= 16 - bf->length; + + return chan << bf->offset; +} + +static int samsung_drm_fbdev_cursor(struct fb_info *info, + struct fb_cursor *cursor) +{ + /* TODO */ + + return 0; +} + +static int samsung_drm_fbdev_setcolreg(unsigned regno, unsigned red, + unsigned green, unsigned blue, unsigned transp, + struct fb_info *info) +{ + unsigned int val; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + switch (info->fix.visual) { + case FB_VISUAL_TRUECOLOR: + if (regno < 16) { + u32 *pal = info->pseudo_palette; + + val = chan_to_field(red, &info->var.red); + val |= chan_to_field(green, &info->var.green); + val |= chan_to_field(blue, &info->var.blue); + + pal[regno] = val; + } + break; + default: + return 1; + } + + return 0; +} + +/** + * define linux framebuffer callbacks. + * - this callback would be used at booting time. + */ +static struct fb_ops samsung_drm_fb_ops = { + .owner = THIS_MODULE, + + .fb_fillrect = cfb_fillrect, + .fb_copyarea = cfb_copyarea, + .fb_imageblit = cfb_imageblit, + + .fb_check_var = drm_fb_helper_check_var, + .fb_set_par = drm_fb_helper_set_par, + .fb_cursor = samsung_drm_fbdev_cursor, + .fb_setcolreg = samsung_drm_fbdev_setcolreg, + .fb_blank = drm_fb_helper_blank, + .fb_pan_display = drm_fb_helper_pan_display, + .fb_setcmap = drm_fb_helper_setcmap, +}; + +/* update fb_info. */ +static int samsung_drm_fbdev_update(struct drm_fb_helper *helper, + struct drm_framebuffer *fb) +{ + struct fb_info *fbi = helper->fbdev; + struct drm_device *dev = helper->dev; + struct samsung_drm_fbdev *samsung_fb = + to_samsung_fbdev_by_helper(helper); + struct samsung_drm_buffer_info buffer_info; + unsigned int size = fb->width * fb->height * (fb->bits_per_pixel >> 3); + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_fb->fb = fb; + + drm_fb_helper_fill_fix(fbi, fb->pitch, fb->depth); + drm_fb_helper_fill_var(fbi, helper, fb->width, fb->height); + + ret = samsung_drm_fb_update_buf_off(fb, fbi->var.xoffset, + fbi->var.yoffset, &buffer_info); + if (ret < 0) { + DRM_ERROR("failed to update framebuffer offset.\n"); + return -EINVAL; + } + + dev->mode_config.fb_base = buffer_info.paddr; + + fbi->screen_base = buffer_info.vaddr; + fbi->screen_size = size; + fbi->fix.smem_start = buffer_info.paddr; + fbi->fix.smem_len = size; + + return 0; +} + +static int samsung_drm_fbdev_create(struct drm_fb_helper *helper, + struct drm_fb_helper_surface_size *sizes) +{ + struct samsung_drm_fbdev *samsung_fbdev = + to_samsung_fbdev_by_helper(helper); + struct drm_device *dev = helper->dev; + struct fb_info *fbi; + struct drm_mode_fb_cmd mode_cmd = {0}; + struct platform_device *pdev = dev->platformdev; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + DRM_DEBUG_KMS("surface width(%d), height(%d) and bpp(%d\n", + sizes->surface_width, sizes->surface_height, + sizes->surface_bpp); + + mode_cmd.width = sizes->surface_width; + mode_cmd.height = sizes->surface_height; + mode_cmd.bpp = sizes->surface_bpp; + mode_cmd.depth = sizes->surface_depth; + + mutex_lock(&dev->struct_mutex); + + fbi = framebuffer_alloc(0, &pdev->dev); + if (!fbi) { + DRM_ERROR("failed to allocate fb info.\n"); + ret = -ENOMEM; + goto out; + } + + samsung_fbdev->fb = samsung_drm_fb_init(NULL, dev, &mode_cmd); + if (IS_ERR(samsung_fbdev->fb)) { + DRM_ERROR("failed to allocate fb.\n"); + ret = PTR_ERR(samsung_fbdev->fb); + goto out; + } + + helper->fb = samsung_fbdev->fb; + helper->fbdev = fbi; + + fbi->par = helper; + fbi->flags = FBINFO_FLAG_DEFAULT; + fbi->fbops = &samsung_drm_fb_ops; + + ret = fb_alloc_cmap(&fbi->cmap, 256, 0); + if (ret) { + DRM_ERROR("failed to allocate cmap.\n"); + goto out; + } + + samsung_drm_fbdev_update(helper, helper->fb); +out: + mutex_unlock(&dev->struct_mutex); + return ret; +} + +static int samsung_drm_fbdev_probe(struct drm_fb_helper *helper, + struct drm_fb_helper_surface_size *sizes) +{ + int ret = -EINVAL; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + if (!helper->fb) { + ret = samsung_drm_fbdev_create(helper, sizes); + if (ret < 0) { + DRM_ERROR("failed to create fbdev.\n"); + return -ENOMEM; + } + + /* + * fb_helper expects a value more than 1 if succeed + * because register_framebuffer() should be called. + */ + ret = 1; + } + + return ret; +} + +static struct drm_fb_helper_funcs samsung_drm_fb_helper_funcs = { + .fb_probe = samsung_drm_fbdev_probe, +}; + +/* initialize drm fbdev helper. */ +int samsung_drm_fbdev_init(struct drm_device *dev) +{ + struct samsung_drm_fbdev *fbdev; + struct samsung_drm_private *private = dev->dev_private; + struct drm_fb_helper *helper; + unsigned int num_crtc = 0; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL); + if (!fbdev) { + DRM_ERROR("failed to allocate drm fbdev.\n"); + return -ENOMEM; + } + + private->fbdev = fbdev; + + helper = &fbdev->drm_fb_helper; + helper->funcs = &samsung_drm_fb_helper_funcs; + + /* get crtc count. */ + num_crtc = dev->mode_config.num_crtc; + + ret = drm_fb_helper_init(dev, helper, num_crtc, 4); + if (ret < 0) { + DRM_ERROR("failed to initialize drm fb helper.\n"); + goto fail; + } + + /** + * all the drm connector objects registered to connector_list + * at previous process would be registered to + * drm_fb_helper->connector_info[n]. + */ + ret = drm_fb_helper_single_add_all_connectors(helper); + if (ret < 0) { + DRM_ERROR("failed to register drm_fb_helper_connector.\n"); + goto fail; + + } + + /** + * all the hardware configurations would be completed by this function + * but if drm_fb_helper->funcs->fb_probe callback returns more then 1. + * drm framework would draw on linux framebuffer and then when + * register_framebuffer() is called, drm_fb_helper_set_par would be + * called by fb_set_par callback.(refer to fb_ops definitions above) + * + * ps. fb_info object is created by fb_probe callback. + */ + ret = drm_fb_helper_initial_config(helper, 32); + if (ret < 0) { + DRM_ERROR("failed to set up hw configuration.\n"); + goto fail; + } + + return ret; +fail: + private->fbdev = NULL; + kfree(fbdev); + + return ret; +} + +static void samsung_drm_fbdev_destroy(struct drm_device *dev, + struct samsung_drm_fbdev *fbdev) +{ + struct fb_info *info; + + if (fbdev->drm_fb_helper.fbdev) { + info = fbdev->drm_fb_helper.fbdev; + unregister_framebuffer(info); + if (info->cmap.len) + fb_dealloc_cmap(&info->cmap); + framebuffer_release(info); + } + + drm_fb_helper_fini(&fbdev->drm_fb_helper); +} + +void samsung_drm_fbdev_fini(struct drm_device *dev) +{ + struct samsung_drm_private *private = dev->dev_private; + if (!private->fbdev) + return; + + samsung_drm_fbdev_destroy(dev, private->fbdev); + kfree(private->fbdev); + private->fbdev = NULL; +} +void samsung_drm_fbdev_restore_mode(struct drm_device *dev) +{ + struct samsung_drm_private *private = dev->dev_private; + + if (!private) + return; + + drm_fb_helper_restore_fbdev_mode(&private->fbdev->drm_fb_helper); +} diff --git a/drivers/gpu/drm/samsung/samsung_drm_fbdev.h b/drivers/gpu/drm/samsung/samsung_drm_fbdev.h new file mode 100644 index 0000000..90b3c25 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_fbdev.h @@ -0,0 +1,38 @@ +/* samsung_drm_fbdev.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * + * Authors: + * Inki Dae, <inki.dae(a)samsung.com> + * Joonyoung Shim, <jy0922.shim(a)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 _SAMSUNG_DRM_FBDEV_H_ +#define _SAMSUNG_DRM_FBDEV_H_ + +/* initialize drm fbdev helper. */ +int samsung_drm_fbdev_init(struct drm_device *dev); +void samsung_drm_fbdev_fini(struct drm_device *dev); + +void samsung_drm_fbdev_restore_mode(struct drm_device *dev); + +#endif diff --git a/drivers/gpu/drm/samsung/samsung_drm_fimd.c b/drivers/gpu/drm/samsung/samsung_drm_fimd.c new file mode 100644 index 0000000..a54884c --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_fimd.c @@ -0,0 +1,609 @@ +/* + * Copyright (C) 2011 Samsung Electronics Co.Ltd + * Author: Joonyoung Shim <jy0922.shim(a)samsung.com> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + */ + +/* + * TODO list + * - Code cleanup(FIXME and TODO parts) + * - Support multiple driver instance + * - Clock gating and Power management + * - Writeback feature + */ + +#include "drmP.h" + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/clk.h> + +#include <drm/samsung_drm.h> +#include <plat/samsung_drm.h> +#include <plat/regs-fb-v4.h> + +/* irq_flags bits */ +#define FIMD_VSYNC_IRQ_EN 0 + +#define VIDOSD_A(win) (VIDOSD_BASE + 0x00 + (win) * 16) +#define VIDOSD_B(win) (VIDOSD_BASE + 0x04 + (win) * 16) +#define VIDOSD_C(win) (VIDOSD_BASE + 0x08 + (win) * 16) +#define VIDOSD_D(win) (VIDOSD_BASE + 0x0C + (win) * 16) + +#define VIDWx_BUF_START(win, buf) (VIDW_BUF_START(buf) + (win) * 8) +#define VIDWx_BUF_END(win, buf) (VIDW_BUF_END(buf) + (win) * 8) +#define VIDWx_BUF_SIZE(win, buf) (VIDW_BUF_SIZE(buf) + (win) * 4) + +#define WINDOWS_NR 5 + +#define get_fimd_data(dev) platform_get_drvdata(to_platform_device(dev)) + +struct fimd_win_data { + unsigned int win_num; + unsigned int offset_x; + unsigned int offset_y; + unsigned int width; + unsigned int height; + unsigned int bpp; + unsigned int paddr; + void __iomem *vaddr; + unsigned int end_buf_off; + unsigned int buf_offsize; + unsigned int line_size; /* bytes */ +}; + +struct fimd_data { + struct clk *bus_clk; + struct resource *regs_res; + void __iomem *regs; + struct fimd_win_data win_data[WINDOWS_NR]; + unsigned int clkdiv; + unsigned long irq_flags; + u32 vidcon0; + u32 vidcon1; +}; + +/* TODO: remove global variables */ +static struct samsung_drm_subdrv fimd_subdrv; +static struct samsung_video_timings fimd_timing; + +static bool fimd_display_is_connected(void) +{ + return true; +} + +static void *fimd_get_timing(void) +{ + return &fimd_timing; +} + +static int fimd_check_timing(void *timing) +{ + return 0; +} + +static int fimd_display_power_on(int mode) +{ + return 0; +} + +static struct samsung_drm_display fimd_display = { + .is_connected = fimd_display_is_connected, + .get_timing = fimd_get_timing, + .check_timing = fimd_check_timing, + .power_on = fimd_display_power_on, +}; + +static struct samsung_drm_display *fimd_get_display(struct device *dev) +{ + return &fimd_display; +} + +static void fimd_commit(struct device *dev) +{ + struct fimd_data *data = get_fimd_data(dev); + void __iomem *regs = data->regs; + u32 val; + + /* vidcon0 */ + val = data->vidcon0; + val &= ~(VIDCON0_CLKVAL_F_MASK | VIDCON0_CLKDIR); + + if (data->clkdiv > 1) + val |= VIDCON0_CLKVAL_F(data->clkdiv - 1) | VIDCON0_CLKDIR; + else + val &= ~VIDCON0_CLKDIR; /* 1:1 clock */ + + val |= VIDCON0_ENVID | VIDCON0_ENVID_F; + writel(val, regs + VIDCON0); + + /* vidcon1 */ + writel(data->vidcon1, regs + VIDCON1); + + /* vidtcon0 */ + val = VIDTCON0_VBPD(fimd_timing.vfp - 1) | + VIDTCON0_VFPD(fimd_timing.vbp - 1) | + VIDTCON0_VSPW(fimd_timing.vsw - 1); + writel(val, regs + VIDTCON0); + + /* vidtcon1 */ + val = VIDTCON1_HBPD(fimd_timing.hfp - 1) | + VIDTCON1_HFPD(fimd_timing.hbp - 1) | + VIDTCON1_HSPW(fimd_timing.hsw - 1); + writel(val, regs + VIDTCON1); + + /* vidtcon2 */ + val = VIDTCON2_LINEVAL(fimd_timing.y_res - 1) | + VIDTCON2_HOZVAL(fimd_timing.x_res - 1); + writel(val, regs + VIDTCON2); +} + +static struct samsung_drm_manager_ops fimd_manager_ops = { + .get_display = fimd_get_display, + .commit = fimd_commit, +}; + +static void fimd_win_mode_set(struct device *dev, + struct samsung_drm_overlay *overlay) +{ + struct fimd_data *data = get_fimd_data(dev); + struct fimd_win_data *win_data; + + if (!overlay) { + dev_err(dev, "overlay is NULL\n"); + return; + } + + win_data = &data->win_data[overlay->win_num]; + + win_data->win_num = overlay->win_num; + win_data->bpp = overlay->bpp; + win_data->offset_x = overlay->offset_x; + win_data->offset_y = overlay->offset_y; + win_data->width = overlay->width; + win_data->height = overlay->height; + win_data->paddr = overlay->paddr; + win_data->vaddr = overlay->vaddr; + win_data->end_buf_off = overlay->end_buf_off; + win_data->buf_offsize = overlay->buf_offsize; + win_data->line_size = overlay->line_size; +} + +static void fimd_win_commit(struct device *dev, unsigned int win) +{ + struct fimd_data *data = get_fimd_data(dev); + void __iomem *regs = data->regs; + struct fimd_win_data *win_data; + u32 val; + + if (win < 0 || win > WINDOWS_NR) + return; + + win_data = &data->win_data[win]; + + /* protect windows */ + val = readl(regs + SHADOWCON); + val |= SHADOWCON_WINx_PROTECT(win); + writel(val, regs + SHADOWCON); + + /* buffer start address */ + val = win_data->paddr; + writel(val, regs + VIDWx_BUF_START(win, 0)); + + /* buffer end address */ + val = win_data->paddr + win_data->end_buf_off; + writel(val, regs + VIDWx_BUF_END(win, 0)); + + /* buffer size */ + val = VIDW_BUF_SIZE_OFFSET(win_data->buf_offsize) | + VIDW_BUF_SIZE_PAGEWIDTH(win_data->line_size); + writel(val, regs + VIDWx_BUF_SIZE(win, 0)); + + /* OSD position */ + val = VIDOSDxA_TOPLEFT_X(win_data->offset_x) | + VIDOSDxA_TOPLEFT_Y(win_data->offset_y); + writel(val, regs + VIDOSD_A(win)); + + val = VIDOSDxB_BOTRIGHT_X(win_data->offset_x + win_data->width - 1) | + VIDOSDxB_BOTRIGHT_Y(win_data->offset_y + win_data->height - 1); + writel(val, regs + VIDOSD_B(win)); + + /* TODO: OSD alpha */ + + /* OSD size */ + if (win != 3 && win != 4) { + u32 offset = VIDOSD_D(win); + if (win == 0) + offset = VIDOSD_C(win); + val = win_data->width * win_data->height; + writel(val, regs + offset); + } + + /* FIXME: remove fixed values */ + val = WINCONx_ENWIN; + val |= WINCON0_BPPMODE_24BPP_888; + val |= WINCONx_WSWP; + val |= WINCONx_BURSTLEN_16WORD; + writel(val, regs + WINCON(win)); + + /* TODO: colour key */ + + /* Enable DMA channel and unprotect windows */ + val = readl(regs + SHADOWCON); + val |= SHADOWCON_CHx_ENABLE(win); + val &= ~SHADOWCON_WINx_PROTECT(win); + writel(val, regs + SHADOWCON); +} + +static void fimd_win_disable(struct device *dev, unsigned int win) +{ + struct fimd_data *data = get_fimd_data(dev); + void __iomem *regs = data->regs; + struct fimd_win_data *win_data; + u32 val; + + if (win < 0 || win > WINDOWS_NR) + return; + + win_data = &data->win_data[win]; + + /* protect windows */ + val = readl(regs + SHADOWCON); + val |= SHADOWCON_WINx_PROTECT(win); + writel(val, regs + SHADOWCON); + + /* wincon */ + val = readl(regs + WINCON(win)); + val &= ~WINCONx_ENWIN; + writel(val, regs + WINCON(win)); + + /* unprotect windows */ + val = readl(regs + SHADOWCON); + val &= ~SHADOWCON_CHx_ENABLE(win); + val &= ~SHADOWCON_WINx_PROTECT(win); + writel(val, regs + SHADOWCON); +} + +static struct samsung_drm_overlay_ops fimd_overlay_ops = { + .mode_set = fimd_win_mode_set, + .commit = fimd_win_commit, + .disable = fimd_win_disable, +}; + +/* for pageflip event */ +static void fimd_finish_pageflip(struct drm_device *drm_dev, int crtc) +{ + struct samsung_drm_private *dev_priv = drm_dev->dev_private; + struct drm_pending_vblank_event *e, *t; + struct timeval now; + unsigned long flags; + + if (!dev_priv->pageflip_event) + return; + + spin_lock_irqsave(&drm_dev->event_lock, flags); + + list_for_each_entry_safe(e, t, &dev_priv->pageflip_event_list, + base.link) { + do_gettimeofday(&now); + e->event.sequence = 0; + e->event.tv_sec = now.tv_sec; + e->event.tv_usec = now.tv_usec; + + list_move_tail(&e->base.link, &e->base.file_priv->event_list); + wake_up_interruptible(&e->base.file_priv->event_wait); + } + + drm_vblank_put(drm_dev, crtc); + dev_priv->pageflip_event = false; + + spin_unlock_irqrestore(&drm_dev->event_lock, flags); +} + +static irqreturn_t fimd_irq_handler(DRM_IRQ_ARGS) +{ + struct drm_device *drm_dev = (struct drm_device *)arg; + struct device *dev = fimd_subdrv.dev; + struct fimd_data *data = get_fimd_data(dev); + void __iomem *regs = data->regs; + u32 val; + + val = readl(regs + VIDINTCON1); + + if (val & VIDINTCON1_INT_FRAME) + /* VSYNC interrupt */ + writel(VIDINTCON1_INT_FRAME, regs + VIDINTCON1); + + /* FIXME: which crtc? */ + drm_handle_vblank(drm_dev, 0); + fimd_finish_pageflip(drm_dev, 0); + + return IRQ_HANDLED; +} + +static void fimd_irq_preinstall(struct drm_device *drm_dev) +{ +} + +static int fimd_irq_postinstall(struct drm_device *drm_dev) +{ + return 0; +} + +static void fimd_irq_uninstall(struct drm_device *drm_dev) +{ +} + +static int fimd_enable_vblank(struct drm_device *drm_dev, int crtc) +{ + struct device *dev = fimd_subdrv.dev; + struct fimd_data *data = get_fimd_data(dev); + void __iomem *regs = data->regs; + u32 val; + + if (!test_and_set_bit(FIMD_VSYNC_IRQ_EN, &data->irq_flags)) { + val = readl(regs + VIDINTCON0); + + val |= VIDINTCON0_INT_ENABLE; + val |= VIDINTCON0_INT_FRAME; + + val &= ~VIDINTCON0_FRAMESEL0_MASK; + val |= VIDINTCON0_FRAMESEL0_VSYNC; + val &= ~VIDINTCON0_FRAMESEL1_MASK; + val |= VIDINTCON0_FRAMESEL1_NONE; + + writel(val, regs + VIDINTCON0); + } + + return 0; +} + +static void fimd_disable_vblank(struct drm_device *drm_dev, int crtc) +{ + struct device *dev = fimd_subdrv.dev; + struct fimd_data *data = get_fimd_data(dev); + void __iomem *regs = data->regs; + u32 val; + + if (test_and_clear_bit(FIMD_VSYNC_IRQ_EN, &data->irq_flags)) { + val = readl(regs + VIDINTCON0); + + val &= ~VIDINTCON0_INT_FRAME; + val &= ~VIDINTCON0_INT_ENABLE; + + writel(val, regs + VIDINTCON0); + } +} + +static int fimd_subdrv_probe(struct drm_device *drm_dev) +{ + struct samsung_drm_private *drm_private = drm_dev->dev_private; + struct drm_driver *drm_driver = drm_dev->driver; + + drm_private->num_crtc++; + + drm_driver->irq_handler = fimd_irq_handler; + drm_driver->irq_preinstall = fimd_irq_preinstall; + drm_driver->irq_postinstall = fimd_irq_postinstall; + drm_driver->irq_uninstall = fimd_irq_uninstall; + drm_driver->enable_vblank = fimd_enable_vblank; + drm_driver->disable_vblank = fimd_disable_vblank; + + return drm_irq_install(drm_dev); +} + +static int fimd_subdrv_remove(struct drm_device *drm_dev) +{ + struct samsung_drm_private *drm_private = drm_dev->dev_private; + struct drm_driver *drm_driver = drm_dev->driver; + + drm_irq_uninstall(drm_dev); + + drm_driver->irq_handler = NULL; + drm_driver->enable_vblank = NULL; + drm_driver->disable_vblank = NULL; + + drm_private->num_crtc--; + + return 0; +} + +static struct samsung_drm_subdrv fimd_subdrv = { + .probe = fimd_subdrv_probe, + .remove = fimd_subdrv_remove, + .manager_ops = &fimd_manager_ops, + .overlay_ops = &fimd_overlay_ops, +}; + +static int fimd_calc_clkdiv(struct fimd_data *data, + struct samsung_video_timings *timing) +{ + unsigned long clk = clk_get_rate(data->bus_clk); + u32 retrace; + u32 clkdiv; + u32 best_framerate = 0; + u32 framerate; + + retrace = timing->hfp + timing->hsw + timing->hbp + timing->x_res; + retrace *= timing->vfp + timing->vsw + timing->vbp + timing->y_res; + + /* default framerate is 60Hz */ + if (!timing->framerate) + timing->framerate = 60; + + clk /= retrace; + + for (clkdiv = 1; clkdiv < 0x100; clkdiv++) { + int tmp; + + /* get best framerate */ + framerate = clk / clkdiv; + tmp = timing->framerate - framerate; + if (tmp < 0) { + best_framerate = framerate; + continue; + } else { + if (!best_framerate) + best_framerate = framerate; + else if (tmp < (best_framerate - framerate)) + best_framerate = framerate ; + break; + } + } + + return clkdiv; +} + +static void fimd_clear_win(struct fimd_data *data, int win) +{ + void __iomem *regs = data->regs; + u32 val; + + writel(0, regs + WINCON(win)); + writel(0, regs + VIDOSD_A(win)); + writel(0, regs + VIDOSD_B(win)); + writel(0, regs + VIDOSD_C(win)); + + if (win == 1 || win == 2) + writel(0, regs + VIDOSD_D(win)); + + val = readl(regs + SHADOWCON); + val &= ~SHADOWCON_WINx_PROTECT(win); + writel(val, regs + SHADOWCON); +} + +static int __devinit fimd_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct fimd_data *data; + struct samsung_drm_fimd_pdata *pdata; + struct resource *res; + int win; + int ret; + + printk(KERN_DEBUG "[%d] %s\n", __LINE__, __func__); + + pdata = pdev->dev.platform_data; + if (!pdata) { + dev_err(dev, "no platform data specified\n"); + return -EINVAL; + } + + data = kzalloc(sizeof(struct fimd_data), GFP_KERNEL); + if (!data) + return -ENOMEM; + + data->bus_clk = clk_get(dev, "lcd"); + if (IS_ERR(data->bus_clk)) { + dev_err(dev, "failed to get bus clock\n"); + ret = PTR_ERR(data->bus_clk); + goto err_data; + } + + clk_enable(data->bus_clk); + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) { + dev_err(dev, "failed to find registers\n"); + ret = -ENOENT; + goto err_clk; + } + + data->regs_res = request_mem_region(res->start, resource_size(res), + dev_name(dev)); + if (!data->regs_res) { + dev_err(dev, "failed to claim register region\n"); + ret = -ENOENT; + goto err_clk; + } + + data->regs = ioremap(res->start, resource_size(res)); + if (!data->regs) { + dev_err(dev, "failed to map registers\n"); + ret = -ENXIO; + goto err_req_region; + } + + if (pdata->setup_gpio) + pdata->setup_gpio(); + + for (win = 0; win < WINDOWS_NR; win++) + fimd_clear_win(data, win); + + data->clkdiv = fimd_calc_clkdiv(data, &pdata->timing); + data->vidcon0 = pdata->vidcon0; + data->vidcon1 = pdata->vidcon1; + + platform_set_drvdata(pdev, data); + + memcpy(&fimd_timing, &pdata->timing, + sizeof(struct samsung_video_timings)); + fimd_timing.vclk = clk_get_rate(data->bus_clk) / data->clkdiv; + + fimd_subdrv.dev = dev; + fimd_subdrv.data = &pdata->subdrv_data; + samsung_drm_subdrv_register(&fimd_subdrv); + + return 0; + +err_req_region: + release_resource(data->regs_res); + kfree(data->regs_res); + +err_clk: + clk_disable(data->bus_clk); + clk_put(data->bus_clk); + +err_data: + kfree(data); + return ret; +} + +static int __devexit fimd_remove(struct platform_device *pdev) +{ + struct fimd_data *data = platform_get_drvdata(pdev); + + iounmap(data->regs); + + clk_disable(data->bus_clk); + clk_put(data->bus_clk); + + release_resource(data->regs_res); + kfree(data->regs_res); + + kfree(data); + + return 0; +} + +static struct platform_driver fimd_driver = { + .probe = fimd_probe, + .remove = __devexit_p(fimd_remove), + .driver = { + .name = "samsung_drm_fimd", + .owner = THIS_MODULE, + }, +}; + +static int __init fimd_init(void) +{ + return platform_driver_register(&fimd_driver); +} + +static void __exit fimd_exit(void) +{ + platform_driver_unregister(&fimd_driver); +} + +subsys_initcall(fimd_init); +module_exit(fimd_exit); + +MODULE_AUTHOR("Joonyoung Shim <jy0922.shim(a)samsung.com>"); +MODULE_DESCRIPTION("Samsung DRM FIMD Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/samsung/samsung_drm_gem.c b/drivers/gpu/drm/samsung/samsung_drm_gem.c new file mode 100644 index 0000000..d485e3c --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_gem.c @@ -0,0 +1,492 @@ +/* samsung_drm_gem.c + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Author: Inki Dae <inki.dae(a)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 "samsung_drm.h" + +#include <plat/samsung_drm.h> + +#include "samsung_drm_gem.h" +#include "samsung_drm_buf.h" + +static unsigned int convert_to_vm_err_msg(int msg) +{ + unsigned int out_msg; + + switch (msg) { + case 0: + case -ERESTARTSYS: + case -EINTR: + out_msg = VM_FAULT_NOPAGE; + break; + + case -ENOMEM: + out_msg = VM_FAULT_OOM; + break; + + default: + out_msg = VM_FAULT_SIGBUS; + break; + } + + return out_msg; +} + +static unsigned int get_gem_mmap_offset(struct drm_gem_object *obj) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + return (unsigned int)obj->map_list.hash.key << PAGE_SHIFT; +} + +/** + * samsung_drm_gem_create_mmap_offset - create a fake mmap offset for an object + * @obj: obj in question + * + * GEM memory mapping works by handing back to userspace a fake mmap offset + * it can use in a subsequent mmap(2) call. The DRM core code then looks + * up the object based on the offset and sets up the various memory mapping + * structures. + * + * This routine allocates and attaches a fake offset for @obj. + */ +static int +samsung_drm_gem_create_mmap_offset(struct drm_gem_object *obj) +{ + struct drm_device *dev = obj->dev; + struct drm_gem_mm *mm = dev->mm_private; + struct drm_map_list *list; + struct drm_local_map *map; + int ret = 0; + + /* Set the object up for mmap'ing */ + list = &obj->map_list; + list->map = kzalloc(sizeof(struct drm_map_list), GFP_KERNEL); + if (!list->map) + return -ENOMEM; + + map = list->map; + map->type = _DRM_GEM; + map->size = obj->size; + map->handle = obj; + + /* Get a DRM GEM mmap offset allocated... */ + list->file_offset_node = drm_mm_search_free(&mm->offset_manager, + obj->size / PAGE_SIZE, + 0, 0); + if (!list->file_offset_node) { + DRM_ERROR("failed to allocate offset for bo %d\n", + obj->name); + ret = -ENOSPC; + goto out_free_list; + } + + list->file_offset_node = drm_mm_get_block(list->file_offset_node, + obj->size / PAGE_SIZE, + 0); + if (!list->file_offset_node) { + ret = -ENOMEM; + goto out_free_list; + } + + list->hash.key = list->file_offset_node->start; + ret = drm_ht_insert_item(&mm->offset_hash, &list->hash); + if (ret) { + DRM_ERROR("failed to add to map hash\n"); + goto out_free_mm; + } + + return 0; + +out_free_mm: + drm_mm_put_block(list->file_offset_node); +out_free_list: + kfree(list->map); + list->map = NULL; + + return ret; +} + +static void +samsung_drm_gem_free_mmap_offset(struct drm_gem_object *obj) +{ + struct drm_device *dev = obj->dev; + struct drm_gem_mm *mm = dev->mm_private; + struct drm_map_list *list = &obj->map_list; + + drm_ht_remove_item(&mm->offset_hash, &list->hash); + drm_mm_put_block(list->file_offset_node); + kfree(list->map); + list->map = NULL; +} + +static int samsung_drm_gem_create(struct drm_file *file, struct drm_device *dev, + unsigned int size, unsigned int *handle_p) +{ + struct samsung_drm_gem_obj *samsung_gem_obj; + struct drm_gem_object *obj; + unsigned int handle; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + size = roundup(size, PAGE_SIZE); + + /* allocate the new buffer object and memory region. */ + samsung_gem_obj = samsung_drm_buf_create(dev, size); + if (!samsung_gem_obj) + return -ENOMEM; + + obj = &samsung_gem_obj->base; + + ret = drm_gem_object_init(dev, obj, size); + if (ret < 0) { + DRM_ERROR("failed to initailize gem object.\n"); + goto out; + } + + DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp); + + ret = samsung_drm_gem_create_mmap_offset(obj); + if (ret < 0) { + DRM_ERROR("failed to allocate mmap offset.\n"); + goto out; + } + + /** + * allocate a id of idr table where the obj is registered + * and handle has the id what user can see. + */ + ret = drm_gem_handle_create(file, obj, &handle); + if (ret) { + drm_gem_object_release(obj); + samsung_drm_buf_destroy(dev, samsung_gem_obj); + goto out; + } + + DRM_DEBUG_KMS("gem handle = 0x%x\n", handle); + + /* drop reference from allocate - handle holds it now. */ + drm_gem_object_unreference_unlocked(obj); + + *handle_p = handle; + + return 0; + +out: + drm_gem_object_unreference_unlocked(obj); + + samsung_drm_buf_destroy(dev, samsung_gem_obj); + + kfree(samsung_gem_obj); + + return ret; +} + +int samsung_drm_gem_create_ioctl(struct drm_device *dev, void *data, + struct drm_file *file) +{ + struct drm_samsung_gem_create *args = data; + + DRM_DEBUG_KMS("%s : size = 0x%x\n", __FILE__, args->size); + + return samsung_drm_gem_create(file, dev, args->size, &args->handle); +} + +int samsung_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data, + struct drm_file *file) +{ + struct drm_samsung_gem_map_off *args = data; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%x\n", + args->handle, (u32)args->offset); + + if (!(dev->driver->driver_features & DRIVER_GEM)) { + DRM_ERROR("not support GEM.\n"); + return -ENODEV; + } + + return samsung_drm_gem_dumb_map_offset(file, dev, args->handle, + &args->offset); +} + +static int samsung_drm_gem_mmap_buffer(struct file *filp, + struct vm_area_struct *vma) +{ + struct drm_gem_object *obj = filp->private_data; + struct samsung_drm_gem_obj *samsung_gem_obj = to_samsung_gem_obj(obj); + struct samsung_drm_buf_entry *entry; + unsigned long pfn, size; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + vma->vm_flags |= (VM_IO | VM_RESERVED); + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); + vma->vm_file = filp; + + size = vma->vm_end - vma->vm_start; + entry = samsung_gem_obj->entry; + + /* check if the region to be mapped is valid or not. */ + if ((entry->paddr + vma->vm_pgoff + size) > + (entry->paddr + entry->size)) { + drm_gem_object_unreference_unlocked(obj); + DRM_ERROR("desired size is bigger then real size.\n"); + return -EINVAL; + } + + pfn = (samsung_gem_obj->entry->paddr + vma->vm_pgoff) >> PAGE_SHIFT; + + DRM_DEBUG_KMS("offset = 0x%x, pfn to be mapped = 0x%x\n", + (u32)vma->vm_pgoff, (u32)pfn); + + if (remap_pfn_range(vma, vma->vm_start, pfn, + vma->vm_end - vma->vm_start, + vma->vm_page_prot)) { + DRM_ERROR("failed to remap pfn range.\n"); + return -EAGAIN; + } + + return 0; +} + +static const struct file_operations samsung_drm_gem_fops = { + .mmap = samsung_drm_gem_mmap_buffer, +}; + +int samsung_drm_gem_mmap_ioctl(struct drm_device *dev, void *data, + struct drm_file *filp) +{ + struct drm_samsung_gem_mmap *args = data; + struct drm_gem_object *obj; + unsigned int addr; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + if (!(dev->driver->driver_features & DRIVER_GEM)) { + DRM_ERROR("not support GEM.\n"); + return -ENODEV; + } + + obj = drm_gem_object_lookup(dev, filp, args->handle); + if (!obj) { + DRM_ERROR("failed to lookup gem object.\n"); + return -EINVAL; + } + + obj->filp->f_op = &samsung_drm_gem_fops; + obj->filp->private_data = obj; + + down_write(&current->mm->mmap_sem); + addr = do_mmap(obj->filp, 0, args->size, + PROT_READ | PROT_WRITE, MAP_SHARED, args->offset); + up_write(&current->mm->mmap_sem); + + drm_gem_object_unreference_unlocked(obj); + + if (IS_ERR((void *)addr)) + return PTR_ERR((void *)addr); + + args->mapped = addr; + + DRM_DEBUG_KMS("mapped = 0x%x\n", args->mapped); + + return 0; +} + +int samsung_drm_gem_init_object(struct drm_gem_object *obj) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + return 0; +} + +void samsung_drm_gem_free_object(struct drm_gem_object *gem_obj) +{ + struct samsung_drm_gem_obj *samsung_gem_obj; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + DRM_DEBUG_KMS("handle count = %d\n", + atomic_read(&gem_obj->handle_count)); + + if (gem_obj->map_list.map) + samsung_drm_gem_free_mmap_offset(gem_obj); + + /* release file pointer to gem object. */ + drm_gem_object_release(gem_obj); + + samsung_gem_obj = to_samsung_gem_obj(gem_obj); + + samsung_drm_buf_destroy(gem_obj->dev, samsung_gem_obj); +} + +struct samsung_drm_gem_obj * + find_samsung_drm_gem_object(struct drm_file *file_priv, + struct drm_device *dev, unsigned int handle) +{ + struct drm_gem_object *gem_obj; + + gem_obj = drm_gem_object_lookup(dev, file_priv, handle); + if (!gem_obj) { + DRM_LOG_KMS("a invalid gem object not registered to lookup.\n"); + return NULL; + } + + /** + * unreference refcount of the gem object. + * at drm_gem_object_lookup(), the gem object was referenced. + */ + drm_gem_object_unreference(gem_obj); + + return to_samsung_gem_obj(gem_obj); +} + +int samsung_drm_gem_dumb_create(struct drm_file *file_priv, + struct drm_device *dev, struct drm_mode_create_dumb *args) +{ + DRM_DEBUG_KMS("%s\n", __FILE__); + + /** + * alocate memory to be used for framebuffer. + * - this callback would be called by user application + * with DRM_IOCTL_MODE_CREATE_DUMB command. + */ + + args->pitch = args->width * args->bpp >> 3; + args->size = args->pitch * args->height; + + return samsung_drm_gem_create(file_priv, dev, args->size, + &args->handle); +} + +int samsung_drm_gem_dumb_map_offset(struct drm_file *file_priv, + struct drm_device *dev, uint32_t handle, uint64_t *offset) +{ + struct samsung_drm_gem_obj *samsung_gem_obj; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + mutex_lock(&dev->struct_mutex); + + /** + * get offset of memory allocated for drm framebuffer. + * - this callback would be called by user application + * with DRM_IOCTL_MODE_MAP_DUMB command. + */ + + samsung_gem_obj = find_samsung_drm_gem_object(file_priv, dev, handle); + if (!samsung_gem_obj) { + DRM_ERROR("failed to get samsung_drm_get_obj.\n"); + mutex_unlock(&dev->struct_mutex); + return -EINVAL; + } + + *offset = get_gem_mmap_offset(&samsung_gem_obj->base); + + DRM_DEBUG_KMS("offset = 0x%x\n", (unsigned int)*offset); + + mutex_unlock(&dev->struct_mutex); + + return 0; +} + +int samsung_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf) +{ + struct drm_gem_object *obj = vma->vm_private_data; + struct samsung_drm_gem_obj *samsung_gem_obj = to_samsung_gem_obj(obj); + struct drm_device *dev = obj->dev; + unsigned long pfn; + pgoff_t page_offset; + int ret; + + page_offset = ((unsigned long)vmf->virtual_address - + vma->vm_start) >> PAGE_SHIFT; + + mutex_lock(&dev->struct_mutex); + + pfn = (samsung_gem_obj->entry->paddr >> PAGE_SHIFT) + page_offset; + + ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn); + + mutex_unlock(&dev->struct_mutex); + + return convert_to_vm_err_msg(ret); +} + +int samsung_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma) +{ + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + /* set vm_area_struct. */ + ret = drm_gem_mmap(filp, vma); + if (ret < 0) { + DRM_ERROR("failed to mmap.\n"); + return ret; + } + + vma->vm_flags &= ~VM_PFNMAP; + vma->vm_flags |= VM_MIXEDMAP; + + return ret; +} + + +int samsung_drm_gem_dumb_destroy(struct drm_file *file_priv, + struct drm_device *dev, unsigned int handle) +{ + struct samsung_drm_gem_obj *samsung_gem_obj; + int ret; + + DRM_DEBUG_KMS("%s\n", __FILE__); + + samsung_gem_obj = find_samsung_drm_gem_object(file_priv, dev, handle); + if (!samsung_gem_obj) { + DRM_ERROR("failed to get samsung_drm_get_obj.\n"); + return -EINVAL; + } + + /** + * obj->refcount and obj->handle_count are decreased and + * if both them are 0 then samsung_drm_gem_free_object() + * would be called by callback to release resources. + */ + ret = drm_gem_handle_delete(file_priv, handle); + if (ret < 0) { + DRM_ERROR("failed to delete drm_gem_handle.\n"); + return ret; + } + + return 0; +} + +MODULE_AUTHOR("Inki Dae <inki.dae(a)samsung.com>"); +MODULE_DESCRIPTION("Samsung SoC DRM GEM Module"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/samsung/samsung_drm_gem.h b/drivers/gpu/drm/samsung/samsung_drm_gem.h new file mode 100644 index 0000000..dbc0ab2 --- /dev/null +++ b/drivers/gpu/drm/samsung/samsung_drm_gem.h @@ -0,0 +1,76 @@ +/* samsung_drm_gem.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authoer: Inki Dae <inki.dae(a)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 _SAMSUNG_DRM_GEM_H_ +#define _SAMSUNG_DRM_GEM_H_ + +#define to_samsung_gem_obj(x) container_of(x,\ + struct samsung_drm_gem_obj, base) + +/* create a new mm object and get a handle to it. */ +int samsung_drm_gem_create_ioctl(struct drm_device *dev, void *data, + struct drm_file *file); + +/* get buffer offset to map to user space. */ +int samsung_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data, + struct drm_file *file); + +/* unmap a buffer from user space. */ +int samsung_drm_gem_munmap_ioctl(struct drm_device *dev, void *data, + struct drm_file *file); + +/* initialize gem object. */ +int samsung_drm_gem_init_object(struct drm_gem_object *obj); + +/* free gem object. */ +void samsung_drm_gem_free_object(struct drm_gem_object *gem_obj); + +struct samsung_drm_gem_obj * + find_samsung_drm_gem_object(struct drm_file *file_priv, + struct drm_device *dev, unsigned int handle); + +/* create memory region for drm framebuffer. */ +int samsung_drm_gem_dumb_create(struct drm_file *file_priv, + struct drm_device *dev, struct drm_mode_create_dumb *args); + +/* map memory region for drm framebuffer to user space. */ +int samsung_drm_gem_dumb_map_offset(struct drm_file *file_priv, + struct drm_device *dev, uint32_t handle, uint64_t *offset); + +/* page fault handler and mmap fault address(virtual) to physical memory. */ +int samsung_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf); + +/* mmap gem object. */ +int samsung_drm_gem_mmap_ioctl(struct drm_device *dev, void *data, + struct drm_file *filp); + +/* set vm_flags and we can change vm attribute to other here. */ +int samsung_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); + +/* destroy memory region allocated. */ +int samsung_drm_gem_dumb_destroy(struct drm_file *file_priv, + struct drm_device *dev, unsigned int handle); + +#endif diff --git a/include/drm/samsung_drm.h b/include/drm/samsung_drm.h new file mode 100644 index 0000000..b554029 --- /dev/null +++ b/include/drm/samsung_drm.h @@ -0,0 +1,274 @@ +/* samsung_drm.h + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd. + * Authors: + * Inki Dae <inki.dae(a)samsung.com> + * Joonyoung Shim <jy0922.shim(a)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 _SAMSUNG_DRM_H_ +#define _SAMSUNG_DRM_H_ + +#include "drm.h" + +struct samsung_drm_overlay; + +/** + * Samsung drm overlay ops structure. + * + * @mode_set: copy drm overlay info to hw specific overlay info. + * @commit: set hw specific overlay into to hw. + */ +struct samsung_drm_overlay_ops { + void (*mode_set)(struct device *subdrv_dev, + struct samsung_drm_overlay *overlay); + void (*commit)(struct device *subdrv_dev, unsigned int win); + void (*disable)(struct device *subdrv_dev, unsigned int win); +}; + +/** + * Samsung drm common overlay structure. + * + * @win_num: window number. + * @offset_x: offset to x position. + * @offset_y: offset to y position. + * @pos_x: x position. + * @pos_y: y position. + * @width: window width. + * @height: window height. + * @bpp: bit per pixel. + * @paddr: physical memory address to this overlay. + * @vaddr: virtual memory addresss to this overlay. + * @buf_off: start offset of framebuffer to be displayed. + * @end_buf_off: end offset of framebuffer to be displayed. + * @buf_offsize: this value has result from + * (framebuffer width - display width) * bpp. + * @line_size: line size to this overlay memory in bytes. + * @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. + * @subdrv_dev: pointer to device object for subdrv device driver. + * @ops: pointer to samsung_drm_overlay_ops. + * + * this structure is common to Samsung SoC and would be copied + * to hardware specific overlay info. + */ +struct samsung_drm_overlay { + unsigned int win_num; + unsigned int offset_x; + unsigned int offset_y; + unsigned int width; + unsigned int height; + unsigned int bpp; + unsigned int paddr; + void __iomem *vaddr; + unsigned int buf_off; + unsigned int end_buf_off; + unsigned int buf_offsize; + unsigned int line_size; + + bool default_win; + bool color_key; + unsigned int index_color; + bool local_path; + bool transparency; + bool activated; + + struct device *subdrv_dev; + struct samsung_drm_overlay_ops *ops; +}; + +/** + * Samsung drm common display information structure. + * + * @display_type: SAMSUNG_DRM_LCD/HDMI or TVOUT. + * @edid: Extended display identification data support or not. + * if true, get_edid() would be called by get_modes() + * of connector helper to get edid tables. + * @id: mean unique display id. + * @default_display: display to be enabled at booting time. + * @activated: activated or not. + * @connected: indicate whether display device of this display type is + * connected or not. + */ +struct samsung_drm_display_info { + unsigned int id; + unsigned int type; + bool edid; + bool default_display; + bool activated; + bool connected; +}; + +/** + * Samsung DRM Display Structure. + * - this structure is common to analog tv, digital tv and lcd panel. + * + * @dev: pointer to specific device object. + * @is_connected: check for that display is connected or not. + * @get_edid: get edid modes from display driver. + * @get_timing: get timing object from display driver. + * @check_timing: check if timing is valid or not. + * @power_on: display device on or off. + */ +struct samsung_drm_display { + struct device *dev; + + bool (*is_connected)(void); + int (*get_edid)(struct drm_connector *connector, u8 *edid, int len); + void *(*get_timing)(void); + int (*check_timing)(void *timing); + int (*power_on)(int mode); +}; + +/** + * Samsung drm manager ops + * + * @get_display: get an pointer of samsung_drm_display object. + * @mode_set: convert drm_display_mode to hw specific display mode and + * would be called by encoder->mode_set(). + * @commit: set current hw specific display mode to hw. + */ +struct samsung_drm_manager_ops { + struct samsung_drm_display *(*get_display)(struct device *subdrv_dev); + void (*mode_set)(struct device *subdrv_dev, void *mode); + void (*commit)(struct device *subdrv_dev); +}; + +/** + * Samsung drm common manager structure. + * + * @subdrv_dev: pointer to device object for subdrv device driver. + * @display_type: SAMSUNG_DRM_LCD/HDMI or TVOUT. + * @display_info: pointer to samsung_drm_display_info object registered. + * @ops: ops pointer to samsung drm common framebuffer. + * ops of fimd or hdmi driver should be set to this ones. + */ +struct samsung_drm_manager { + struct device *subdrv_dev; + unsigned int display_type; + struct samsung_drm_display_info *display_info; + struct samsung_drm_manager_ops *ops; +}; + +/** + * Samsung drm private structure. + * + * @fbdev + * @num_crtc: probed display driver count. + * this variable would be used to get possible crtc. + */ +struct samsung_drm_private { + struct samsung_drm_fbdev *fbdev; + + unsigned int num_crtc; + + /* FIXME */ + /* for pageflip */ + struct list_head pageflip_event_list; + bool pageflip_event; + + /* add some structures. */ +}; + +struct samsung_drm_subdrv { + struct device *dev; + struct list_head list; + + /* driver ops */ + int (*probe)(struct drm_device *dev); + int (*remove)(struct drm_device *dev); + + struct samsung_drm_manager_ops *manager_ops; + struct samsung_drm_overlay_ops *overlay_ops; + + void *data; +}; + +void samsung_drm_subdrv_register(struct samsung_drm_subdrv *drm_subdrv); +void samsung_drm_subdrv_unregister(struct samsung_drm_subdrv *drm_subdrv); + +/** + * User-desired buffer creation information structure. + * + * @usr_addr: an address allocated by user process and this address + * would be mmapped to physical region by fault handler. + * @size: requested size for the object. + * - this size value would be page-aligned internally. + * @flags: user request for setting memory type or cache attributes. + * @handle: returned handle for the object. + */ +struct drm_samsung_gem_create { + unsigned int usr_addr; + unsigned int size; + unsigned int flags; + + unsigned int handle; +}; + +/** + * A structure for getting buffer offset. + * + * @handle: a pointer to gem object created. + * @offset: relatived offset value of the memory region allocated. + * - this value should be set by user. + */ +struct drm_samsung_gem_map_off { + unsigned int handle; + uint64_t offset; +}; + +/** + * A structure for mapping buffer. + * + * @handle: a pointer to gem object created. + * @offset: relatived offset value of the memory region allocated. + * - this value should be set by user. + * @size: memory size to be mapped. + * @mapped: user virtual address to be mapped. + */ +struct drm_samsung_gem_mmap { + unsigned int handle; + uint64_t offset; + unsigned int size; + + unsigned int mapped; +}; + +#define DRM_SAMSUNG_GEM_CREATE 0x00 +#define DRM_SAMSUNG_GEM_MAP_OFFSET 0x01 +#define DRM_SAMSUNG_GEM_MMAP 0x02 + +#define DRM_IOCTL_SAMSUNG_GEM_CREATE DRM_IOWR(DRM_COMMAND_BASE + \ + DRM_SAMSUNG_GEM_CREATE, struct drm_samsung_gem_create) + +#define DRM_IOCTL_SAMSUNG_GEM_MAP_OFFSET DRM_IOWR(DRM_COMMAND_BASE + \ + DRM_SAMSUNG_GEM_MAP_OFFSET, struct drm_samsung_gem_map_off) + +#define DRM_IOCTL_SAMSUNG_GEM_MMAP DRM_IOWR(DRM_COMMAND_BASE + \ + DRM_SAMSUNG_GEM_MMAP, struct drm_samsung_gem_mmap) + +#endif -- 1.7.0.4

1 1

Empty /proc/dri/0/bufs queues
by Vipin 11 Aug '11

11 Aug '11

Hello all, I have been trying to study the radeon open source driver and have some questions after turning the debug flag on. System Information --------------- uname -a Linux gilubuntu1 3.0.1vipindebug #1 SMP Thu Aug 11 11:17:24 EDT 2011 i686 GNU/Linux kernel option - drm.debug=1 glxinfo | grep rendering direct rendering: Yes lspci -vvv | grep ATI 01:00.0 VGA compatible controller: ATI Technologies Inc RV710 [Radeon HD 4550] (prog-if 00 [VGA controller]) Subsystem: ATI Technologies Inc Device 0104 lsmod - relevant entries ttm 110688 1 radeon drm_kms_helper 49424 1 radeon drm 317625 5 radeon,ttm,drm_kms_helper agpgart 56250 2 ttm,drm i2c_algo_bit 10782 1 radeon --------------------------------------------------------------------- Question 1. Empty /proc/dri/0 bufs, queues files Is this an expected behavior ? I have tried generating extensive 3D workloads, but the file remains empty. Question 2. /sys/kernel/debug/dri/ There are two directories 0 & 64, what does the 64 entry signify ? Question 3. The contents of /sys/kernel/debug/dri/0 contains 15 radeon_ib_00xx Does this mean, the card has 15 indirect buffers ? Also, does this interface shows me the ringbuffer data like i915. Question 4. The kernel log shows entries like these (massive amounts) Aug 11 13:19:01 gilubuntu1 kernel: [ 4251.705377] [drm:drm_ioctl], pid=1544, cmd=0xc0086464, nr=0x64, dev 0xe200, auth=1 Aug 11 13:19:01 gilubuntu1 kernel: [ 4251.705394] [drm:r600_irq_set], r600_irq_set: sw int Shouldn't it have other debug entries other than these two ? Thank You Vipin Jain

1 0

[PATCH] drm/radeon/kms: fix regression is handling >2 heads on cedar/caicos
by alexdeucher＠gmail.com 11 Aug '11

11 Aug '11

From: Alex Deucher <alexander.deucher(a)amd.com> Need to add support for 4 crtcs when setting the possible crtcs for the encoders. Signed-off-by: Alex Deucher <alexander.deucher(a)amd.com> Cc: stable(a)kernel.org --- drivers/gpu/drm/radeon/radeon_encoders.c | 3 +++ 1 files changed, 3 insertions(+), 0 deletions(-) diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c index 4c4d8e5..39cfef6 100644 --- a/drivers/gpu/drm/radeon/radeon_encoders.c +++ b/drivers/gpu/drm/radeon/radeon_encoders.c @@ -2394,6 +2394,9 @@ radeon_add_atom_encoder(struct drm_device *dev, default: encoder->possible_crtcs = 0x3; break; + case 4: + encoder->possible_crtcs = 0xf; + break; case 6: encoder->possible_crtcs = 0x3f; break; -- 1.7.1.1

1 0

[Bug 28125] New: DRI2 prevents indirect glx
by bugzilla-daemon＠freedesktop.org 11 Aug '11

11 Aug '11

https://bugs.freedesktop.org/show_bug.cgi?id=28125 Summary: DRI2 prevents indirect glx Product: DRI Version: XOrg CVS Platform: Other OS/Version: All Status: NEW Severity: normal Priority: medium Component: General AssignedTo: dri-devel(a)lists.freedesktop.org ReportedBy: NightNord(a)gmail.com When running glx programs with dri2-enabled mesa on client side, it will return X Error of failed request: BadRequest (invalid request code or no such operation) Major opcode of failed request: 128 (DRI2) Minor opcode of failed request: 1 (DRI2Connect) Serial number of failed request: 19 Current serial number in output stream: 19 export LIBG_ALWAYS_INDIRECT=1 does the trick -- Configure bugmail: https://bugs.freedesktop.org/userprefs.cgi?tab=email ------- You are receiving this mail because: ------- You are the assignee for the bug.

1 7

[PATCH -next] drm: fix kconfig unmet dependency warning
by Randy Dunlap 10 Aug '11

10 Aug '11

From: Randy Dunlap <rdunlap(a)xenotime.net> Fix kconfig unmet dependency warning. BACKLIGHT_CLASS_DEVICE depends on BACKLIGHT_LCD_SUPPORT, so select the latter along with the former. warning: (DRM_RADEON_KMS && DRM_I915 && STUB_POULSBO && FB_BACKLIGHT && PANEL_SHARP_LS037V7DW01 && PANEL_ACX565AKM && USB_APPLEDISPLAY && FB_OLPC_DCON && ASUS_LAPTOP && SONY_LAPTOP && THINKPAD_ACPI && EEEPC_LAPTOP && ACPI_ASUS && ACPI_CMPC && SAMSUNG_Q10) selects BACKLIGHT_CLASS_DEVICE which has unmet direct dependencies (HAS_IOMEM && BACKLIGHT_LCD_SUPPORT) Signed-off-by: Randy Dunlap <rdunlap(a)xenotime.net> --- drivers/gpu/drm/Kconfig | 1 + 1 file changed, 1 insertion(+) --- lnx-31-rc1.orig/drivers/gpu/drm/Kconfig +++ lnx-31-rc1/drivers/gpu/drm/Kconfig @@ -96,6 +96,7 @@ config DRM_I915 select FB_CFB_IMAGEBLIT # i915 depends on ACPI_VIDEO when ACPI is enabled # but for select to work, need to select ACPI_VIDEO's dependencies, ick + select BACKLIGHT_LCD_SUPPORT if ACPI select BACKLIGHT_CLASS_DEVICE if ACPI select VIDEO_OUTPUT_CONTROL if ACPI select INPUT if ACPI

1 1

KMS resume sequence
by Yeh, Sinclair 10 Aug '11

10 Aug '11

After my system sit idle for a while, my driver gets the following calls to turn off display: encoder_dpms crtc_dpms I then use the keyboard to resume. Upon resuming, I can see two calls: crtc_set_config, and crtc_load_lut. The display remains turned off because I am not getting calls to encoder_dpms or connector_dpms. As an extra data point, currently I am using drm_helper_crtc_set_config(), and I've noticed that both mode_changed and fb_changed are FALSE, which means set_config is not going to try and set a mode or update the mode base. Regardless of what set_config is doing, since KMS used dpms functions to turn off the display, I'd expect it to use them to turn them back on. If this is not the case, then can someone let me know where the expected place to turn the display(s) back on may be? Thanks, Sinclair

1 0

[PULL] drm-intel-next
by Keith Packard 10 Aug '11

10 Aug '11

Here's a pile of fixes on top of the stuff already in drm-core-next. * Pile of mode setting fixes which eliminate a selection of bugs and other annoyances. Eliminates the 'stripey' effect when going from two to one monitor, makes hot-plug work after suspend/resume, turns off the pipe/plane in DPMS off. * DP mode setting cleanups and pessimizations that should recover from unexpected situations better. * HDMI info frame changes, including the addition of SPD (source product description) frames. * RC6 enabled by default (again). Given that we don't understand why it doesn't work, and that we've found and fixed at least a couple of RC6-related bugs, maybe it works now? Prepare to see this reverted before 3.1 if we get regression reports (sigh). The following changes since commit 5a96a899bbdee86024ab9ea6d02b9e242faacbed Merge branch 'drm-core-next' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6 (2011-07-26 09:21:09 -0700) are available in the git repository at: ssh://master.kernel.org/pub/scm/linux/kernel/git/keithp/linux-2.6.git drm-intel-next Adam Jackson (10): drm/i915/dp: Zero the DPCD data before connection probe drm/i915/dp: Move DPCD dump to common code instead of PCH-only drm/i915/dp: Read more DPCD registers on connection probe drm/i915/dp: Better hexdump of DPCD drm/i915/dp: Retry DPCD fetch on G4X too drm/i915/dp: Explicitly request 8/10 channel coding drm/i915/pch: Fix integer math bugs in panel fitting drm/i915/dp: Explicitly disable symbol scrambling while training drm/i915/dp: Don't turn CPT DP ports on too early drm/i915/pch: Save/restore PCH_PORT_HOTPLUG across suspend Jesse Barnes (15): drm/i915: provide more error output when mode sets fail drm/i915: load the LUT before pipe enable on ILK+ drm/i915: apply timing generator bug workaround on CPT and PPT drm/i915: flush plane control changes on ILK+ as well drm/i915: fix CB tuning check for ILK+ drm/i915/hdmi: send AVI info frames on ILK+ as well drm/i915: add GPU max frequency control file drm/i915: provide more error output when mode sets fail drm/i915: apply phase pointer override on SNB+ too drm/i915: don't use uninitialized EDID bpc values when picking pipe bpp drm/i915/dp: wait for previous AUX channel activity to clear drm: track CEA version number if present drm/i915/hdmi: split infoframe setting from infoframe type code drm/i915/hdmi: HDMI source product description infoframe support drm/i915: allow cache sharing policy control Keith Packard (14): drm/i915: Skip GPU wait for scanout pin while wedged drm/i915: Initialize RCS ring status page address in intel_render_ring_init_dri drm/i915: Hold mode_config->mutex during hotplug processing drm/i915: Fixup for 'Hold mode_config->mutex during hotplug' drm/i915: Use dp_detect_common in hotplug helper function drm/i915: Rename i915_dp_detect_common to intel_dp_get_dpcd drm/i915: In intel_dp_init, replace read of DPCD with intel_dp_get_dpcd drm/i915: DP_PIPE_ENABLED must check transcoder on CPT Revert and fix "drm/i915/dp: remove DPMS mode tracking from DP" drm/i915: Set crtc DPMS mode to ON in intel_crtc_mode_set drm/i915: Flush other plane register writes drm/i915: Ignore GPU wedged errors while pinning scanout buffers Revert "drm/i915/dp: Zero the DPCD data before connection probe" drm/i915: Try enabling RC6 by default (again) Michel Alexandre Salim (1): drm/i915: Add quirk to disable SSC on Sony Vaio Y2 Ole Henrik Jahren (1): drm/i915: Fix typo in DRM_I915_OVERLAY_PUT_IMAGE ioctl define Pieterjan Camerlynck (1): i915: add Dell OptiPlex FX170 to intel_no_lvds drivers/gpu/drm/drm_edid.c | 9 ++ drivers/gpu/drm/i915/i915_debugfs.c | 189 +++++++++++++++++++++++++++++++ drivers/gpu/drm/i915/i915_dma.c | 6 +- drivers/gpu/drm/i915/i915_drv.c | 2 +- drivers/gpu/drm/i915/i915_drv.h | 1 + drivers/gpu/drm/i915/i915_gem.c | 2 +- drivers/gpu/drm/i915/i915_irq.c | 3 + drivers/gpu/drm/i915/i915_reg.h | 36 ++++++- drivers/gpu/drm/i915/i915_suspend.c | 2 + drivers/gpu/drm/i915/intel_display.c | 138 ++++++++++++++++++----- drivers/gpu/drm/i915/intel_dp.c | 111 ++++++++++++------- drivers/gpu/drm/i915/intel_drv.h | 23 ++++ drivers/gpu/drm/i915/intel_hdmi.c | 158 ++++++++++++++++++++++---- drivers/gpu/drm/i915/intel_lvds.c | 8 ++ drivers/gpu/drm/i915/intel_panel.c | 4 + drivers/gpu/drm/i915/intel_ringbuffer.c | 3 + include/drm/drm_crtc.h | 2 + include/drm/i915_drm.h | 2 +- 18 files changed, 594 insertions(+), 105 deletions(-) -- keith.packard(a)intel.com

2 2

[Bug 39696] New: dual head: different vert refresh freq, applications sync to the wrong one
by bugzilla-daemon＠freedesktop.org 10 Aug '11

10 Aug '11

https://bugs.freedesktop.org/show_bug.cgi?id=39696 Summary: dual head: different vert refresh freq, applications sync to the wrong one Product: DRI Version: unspecified Platform: Other OS/Version: All Status: NEW Severity: major Priority: medium Component: DRM/Radeon AssignedTo: dri-devel(a)lists.freedesktop.org ReportedBy: klaus.kusche(a)computerix.info I've a notebook with a JUNIPER 0x1002:0x68A0 chip, using KMS, dri and gallium. I mostly use external monitors connected by display port, HDMI or DVI, cloning the internal display onto them (identical resolution, identical screen). No matter what monitor (I tried two different Dell, an Iiyama and an Acer) and what port (DVI, HDMI, DP) I use, KMS always sets sligthly different vertical refresh frequencies: The internal display runs at 60 Hz, the external monitor runs at 59.9 Hz. However, although I only look at the external monitor, all applications (both 3D/DRM and video/Xv) sync to the vert refresh of the internal display. This results in very nasty tearing effects: A clearly visible horizontal offset line moves up slowly on the external monitor for any video or 3D application (cyclically with a period of about 10 seconds). 1.) Is there a way to run both displays at exactly the same vert frequency and with synchronized vertical retrace? 2.) Is there a way to switch 3D and video application sync from the internal to the external vsync rate? -- Configure bugmail: https://bugs.freedesktop.org/userprefs.cgi?tab=email ------- You are receiving this mail because: ------- You are the assignee for the bug.

1 14

[PATCH 1/3] drm/gem: add functions for mmap offset creation
by Rob Clark 10 Aug '11

10 Aug '11

Signed-off-by: Rob Clark <rob(a)ti.com> --- drivers/gpu/drm/drm_gem.c | 88 +++++++++++++++++++++++++++++++++++++++++++++ include/drm/drmP.h | 3 ++ 2 files changed, 91 insertions(+), 0 deletions(-) diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c index 2b997d2..809358a 100644 --- a/drivers/gpu/drm/drm_gem.c +++ b/drivers/gpu/drm/drm_gem.c @@ -273,6 +273,94 @@ again: } EXPORT_SYMBOL(drm_gem_handle_create); + +/** + * drm_gem_free_mmap_offset - release a fake mmap offset for an object + * @obj: obj in question + * + * This routine frees fake offsets allocated by drm_gem_create_mmap_offset(). + */ +void +drm_gem_free_mmap_offset(struct drm_gem_object *obj) +{ + struct drm_device *dev = obj->dev; + struct drm_gem_mm *mm = dev->mm_private; + struct drm_map_list *list = &obj->map_list; + + drm_ht_remove_item(&mm->offset_hash, &list->hash); + drm_mm_put_block(list->file_offset_node); + kfree(list->map); + list->map = NULL; +} +EXPORT_SYMBOL(drm_gem_free_mmap_offset); + +/** + * drm_gem_create_mmap_offset - create a fake mmap offset for an object + * @obj: obj in question + * + * GEM memory mapping works by handing back to userspace a fake mmap offset + * it can use in a subsequent mmap(2) call. The DRM core code then looks + * up the object based on the offset and sets up the various memory mapping + * structures. + * + * This routine allocates and attaches a fake offset for @obj. + */ +int +drm_gem_create_mmap_offset(struct drm_gem_object *obj) +{ + struct drm_device *dev = obj->dev; + struct drm_gem_mm *mm = dev->mm_private; + struct drm_map_list *list; + struct drm_local_map *map; + int ret = 0; + + /* Set the object up for mmap'ing */ + list = &obj->map_list; + list->map = kzalloc(sizeof(struct drm_map_list), GFP_KERNEL); + if (!list->map) + return -ENOMEM; + + map = list->map; + map->type = _DRM_GEM; + map->size = obj->size; + map->handle = obj; + + /* Get a DRM GEM mmap offset allocated... */ + list->file_offset_node = drm_mm_search_free(&mm->offset_manager, + obj->size / PAGE_SIZE, 0, 0); + + if (!list->file_offset_node) { + DRM_ERROR("failed to allocate offset for bo %d\n", obj->name); + ret = -ENOSPC; + goto out_free_list; + } + + list->file_offset_node = drm_mm_get_block(list->file_offset_node, + obj->size / PAGE_SIZE, 0); + if (!list->file_offset_node) { + ret = -ENOMEM; + goto out_free_list; + } + + list->hash.key = list->file_offset_node->start; + ret = drm_ht_insert_item(&mm->offset_hash, &list->hash); + if (ret) { + DRM_ERROR("failed to add to map hash\n"); + goto out_free_mm; + } + + return 0; + +out_free_mm: + drm_mm_put_block(list->file_offset_node); +out_free_list: + kfree(list->map); + list->map = NULL; + + return ret; +} +EXPORT_SYMBOL(drm_gem_create_mmap_offset); + /** Returns a reference to the object named by the handle. */ struct drm_gem_object * drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp, diff --git a/include/drm/drmP.h b/include/drm/drmP.h index 111e98f..ec156c3 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h @@ -1622,6 +1622,9 @@ drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj) drm_gem_object_unreference_unlocked(obj); } +void drm_gem_free_mmap_offset(struct drm_gem_object *obj); +int drm_gem_create_mmap_offset(struct drm_gem_object *obj); + struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp, u32 handle); -- 1.7.5.4

1 2

← Newer
1
...
37
38
39
40
41
42
43
...
47
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

dri-devel August 2011