shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-07 19:30:30 +09:00
Code Issues Packages Projects Releases Wiki Activity

rk3288 chromium: update drm fb

Browse Source
This commit is contained in:
yzq
2014-03-31 15:42:15 +08:00
parent d84dbedb86
commit 966b5dfe14
16 changed files with 1568 additions and 2717 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
arch/arm/configs/rockchip_chromium_defconfig
View File

@@ -327,28 +327,26 @@ CONFIG_V4L_PLATFORM_DRIVERS=y
CONFIG_DRM=y
CONFIG_DRM_ROCKCHIP=y
CONFIG_DRM_ROCKCHIP_DMABUF=y
CONFIG_DRM_RK3288_FIMD=y
CONFIG_DRM_RK_PRIMARY=y
CONFIG_MALI_T6XX=y
CONFIG_MALI_GATOR_SUPPORT=y
CONFIG_MALI_T6XX_DVFS=y
CONFIG_MALI_T6XX_RT_PM=y
CONFIG_MALI_T6XX_ENABLE_TRACE=y
CONFIG_MALI_T6XX_DEBUG_SYS=y
CONFIG_MALI_EXPERT=y
CONFIG_MALI_DEBUG_SHADER_SPLIT_FS=y
CONFIG_MALI_PLATFORM_THIRDPARTY_NAME="rk"
CONFIG_MALI_DEBUG=y
CONFIG_MALI_TRACE_TIMELINE=y
CONFIG_MALI_SYSTEM_TRACE=y
CONFIG_BACKLIGHT_LCD_SUPPORT=y
# CONFIG_LCD_CLASS_DEVICE is not set
CONFIG_BACKLIGHT_CLASS_DEVICE=y
# CONFIG_BACKLIGHT_GENERIC is not set
CONFIG_BACKLIGHT_PWM=y
CONFIG_LCDC_RK3288=y
CONFIG_LCD_GENERAL=y
CONFIG_RK_TRSM=y
CONFIG_RK32_LVDS=y
CONFIG_ROCKCHIP_RGA2=y
# CONFIG_IEP is not set
CONFIG_LOGO=y
# CONFIG_LOGO_LINUX_MONO is not set
# CONFIG_LOGO_LINUX_VGA16 is not set

24
drivers/gpu/drm/rockchip/Kconfig
View File

@@ -22,23 +22,13 @@ config DRM_ROCKCHIP_DMABUF
help
Choose this option if you want to use DMABUF feature for DRM.
config DRM_RK3188_FIMD
bool "RK3188 DRM FIMD"
depends on OF && DRM_ROCKCHIP
select FB_MODE_HELPERS
select VIDEOMODE_HELPERS
help
Choose this option if you want to use Rockchip FIMD for DRM.
config DRM_RK3288_FIMD
bool "RK3288 DRM FIMD"
depends on OF && DRM_ROCKCHIP
select FB_MODE_HELPERS
select VIDEOMODE_HELPERS
help
Choose this option if you want to use Rockchip FIMD for DRM.
config DRM_RK_PRIMARY
bool "RK DRM PRIMARY"
depends on OF && DRM_ROCKCHIP
select FB_MODE_HELPERS
select VIDEOMODE_HELPERS
help
Choose this option if you want to use Rockchip PRIMARY DISPLAY for DRM.
config DRM_ROCKCHIP_HDMI
bool "Rockchip DRM HDMI"
depends on DRM_ROCKCHIP

7
drivers/gpu/drm/rockchip/Makefile
View File

@@ -6,17 +6,14 @@ ccflags-y := -Iinclude/drm -Idrivers/gpu/drm/rockchip
rockchipdrm-y := rockchip_drm_drv.o rockchip_drm_encoder.o rockchip_drm_connector.o \
rockchip_drm_crtc.o rockchip_drm_fbdev.o rockchip_drm_fb.o \
rockchip_drm_buf.o rockchip_drm_gem.o rockchip_drm_core.o \
rockchip_drm_plane.o
rockchip_drm_plane.o
rockchipdrm-$(CONFIG_DRM_ROCKCHIP_IOMMU) += rockchip_drm_iommu.o
rockchipdrm-$(CONFIG_DRM_ROCKCHIP_DMABUF) += rockchip_drm_dmabuf.o
rockchipdrm-$(CONFIG_DRM_RK3188_FIMD) += rk3188_drm_fimd.o
rockchipdrm-$(CONFIG_DRM_RK3288_FIMD) += rk3288_drm_fimd.o
rockchipdrm-$(CONFIG_DRM_RK_PRIMARY) += rockchip_drm_primary.o
rockchipdrm-$(CONFIG_DRM_ROCKCHIP_HDMI) += rockchip_hdmi.o rockchip_mixer.o \
rockchip_ddc.o rockchip_hdmiphy.o \
rockchip_drm_hdmi.o
rockchipdrm-$(CONFIG_DRM_ROCKCHIP_VIDI) += rockchip_drm_vidi.o
obj-$(CONFIG_DRM_ROCKCHIP) += rockchipdrm.o
obj-$(CONFIG_DRM_ROCKCHIP) += ../../../video/rockchip/screen/
obj-$(CONFIG_DRM_ROCKCHIP) += ../../../video/rockchip/transmitter/

1170
drivers/gpu/drm/rockchip/rk3188_drm_fimd.c
View File

File diff suppressed because it is too large Load Diff

1480
drivers/gpu/drm/rockchip/rk3288_drm_fimd.c
View File

File diff suppressed because it is too large Load Diff

37
drivers/gpu/drm/rockchip/rockchip_drm_drv.c
View File

@@ -43,7 +43,6 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
int ret;
int nr;
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
DRM_DEBUG_DRIVER("%s\n", __FILE__);
private = kzalloc(sizeof(struct rockchip_drm_private), GFP_KERNEL);
@@ -52,7 +51,6 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
return -ENOMEM;
}
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
INIT_LIST_HEAD(&private->pageflip_event_list);
dev->dev_private = (void *)private;
@@ -62,14 +60,12 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
* also this iommu_mapping can be used to check if iommu is supported
* or not.
*/
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
ret = drm_create_iommu_mapping(dev);
if (ret < 0) {
DRM_ERROR("failed to create iommu mapping.\n");
goto err_crtc;
}
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
drm_mode_config_init(dev);
/* init kms poll for handling hpd */
@@ -81,14 +77,12 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
* ROCKCHIP4 is enough to have two CRTCs and each crtc would be used
* without dependency of hardware.
*/
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
for (nr = 0; nr < MAX_CRTC; nr++) {
ret = rockchip_drm_crtc_create(dev, nr);
if (ret)
goto err_release_iommu_mapping;
}
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
for (nr = 0; nr < MAX_PLANE; nr++) {
struct drm_plane *plane;
unsigned int possible_crtcs = (1 << MAX_CRTC) - 1;
@@ -98,7 +92,6 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
goto err_release_iommu_mapping;
}
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
ret = drm_vblank_init(dev, MAX_CRTC);
if (ret)
goto err_release_iommu_mapping;
@@ -108,7 +101,6 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
* that were registered at probe() of platform driver
* to the sub driver and create encoder and connector for them.
*/
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
ret = rockchip_drm_device_register(dev);
if (ret)
goto err_vblank;
@@ -116,12 +108,10 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
/* setup possible_clones. */
rockchip_drm_encoder_setup(dev);
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
/*
* create and configure fb helper and also rockchip specific
* fbdev object.
*/
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
ret = rockchip_drm_fbdev_init(dev);
if (ret) {
DRM_ERROR("failed to initialize drm fbdev\n");
@@ -130,7 +120,6 @@ static int rockchip_drm_load(struct drm_device *dev, unsigned long flags)
drm_vblank_offdelay = VBLANK_OFF_DELAY;
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
return 0;
err_drm_device:
@@ -168,7 +157,6 @@ static int rockchip_drm_open(struct drm_device *dev, struct drm_file *file)
{
struct drm_rockchip_file_private *file_priv;
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
DRM_DEBUG_DRIVER("%s\n", __FILE__);
file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
@@ -286,7 +274,6 @@ static struct drm_driver rockchip_drm_driver = {
static int rockchip_drm_platform_probe(struct platform_device *pdev)
{
DRM_DEBUG_DRIVER("%s\n", __FILE__);
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
rockchip_drm_driver.num_ioctls = DRM_ARRAY_SIZE(rockchip_ioctls);
@@ -297,7 +284,6 @@ static int rockchip_drm_platform_probe(struct platform_device *pdev)
static int rockchip_drm_platform_remove(struct platform_device *pdev)
{
DRM_DEBUG_DRIVER("%s\n", __FILE__);
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
drm_platform_exit(&rockchip_drm_driver, pdev);
@@ -319,24 +305,20 @@ static int __init rockchip_drm_init(void)
DRM_DEBUG_DRIVER("%s\n", __FILE__);
#ifdef CONFIG_DRM_RK3288_FIMD
ret = platform_driver_register(&fimd_driver);
if (ret < 0)
goto out_fimd;
#endif
#ifdef CONFIG_DRM_RK3188_FIMD
ret = platform_driver_register(&fimd_driver);
#ifdef CONFIG_DRM_RK_PRIMARY
ret = platform_driver_register(&primary_platform_driver);
if (ret < 0)
goto out_fimd;
platform_device_register_simple("primary-display", -1,
NULL, 0);
#endif
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
ret = platform_driver_register(&rockchip_drm_platform_driver);
if (ret < 0)
goto out_drm;
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
rockchip_drm_pdev = platform_device_register_simple("rockchip-drm", -1,
NULL, 0);
if (IS_ERR(rockchip_drm_pdev)) {
@@ -344,18 +326,13 @@ static int __init rockchip_drm_init(void)
goto out;
}
printk(KERN_ERR"----->yzq %s %d\n",__func__,__LINE__);
return 0;
out:
platform_driver_unregister(&rockchip_drm_platform_driver);
out_drm:
#ifdef CONFIG_DRM_RK3188_FIMD
platform_driver_unregister(&fimd_driver);
out_fimd:
#endif
#ifdef CONFIG_DRM_RK3288_FIMD
platform_driver_unregister(&fimd_driver);
#ifdef CONFIG_DRM_RK_PRIMARY
platform_driver_unregister(&primary_platform_driver);
out_fimd:
#endif
return ret;

2
drivers/gpu/drm/rockchip/rockchip_drm_drv.h
View File

@@ -337,7 +337,7 @@ int rockchip_platform_device_ipp_register(void);
*/
void rockchip_platform_device_ipp_unregister(void);
extern struct platform_driver fimd_driver;
extern struct platform_driver primary_platform_driver;
extern struct platform_driver hdmi_driver;
extern struct platform_driver mixer_driver;
extern struct platform_driver rockchip_drm_common_hdmi_driver;

659
drivers/gpu/drm/rockchip/rockchip_drm_primary.c Normal file
View File

@@ -0,0 +1,659 @@
/*
* rk3288_drm_fimd.c
*
* Copyright (C) ROCKCHIP, Inc.
* Author:yzq<yzq@rock-chips.com>
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <drm/drmP.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/of_device.h>
#include <linux/pm_runtime.h>
#include <video/of_display_timing.h>
#include <drm/rockchip_drm.h>
#include <linux/rockchip/cpu.h>
#include <linux/rockchip/iomap.h>
#include <linux/rk_fb.h>
#include <video/display_timing.h>
#include <linux/rockchip/cpu.h>
#include <linux/rockchip/iomap.h>
#include <linux/rockchip/grf.h>
#include "rockchip_drm_drv.h"
#include "rockchip_drm_fbdev.h"
#include "rockchip_drm_crtc.h"
#include "rockchip_drm_iommu.h"
#include "rockchip_drm_primary.h"
static struct device *g_dev = NULL;
static bool primary_display_is_connected(struct device *dev)
{
DRM_DEBUG_KMS("%s\n", __FILE__);
/* TODO. */
return true;
}
static void *primary_get_panel(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
DRM_DEBUG_KMS("%s\n", __FILE__);
return ctx->panel;
}
static int primary_check_timing(struct device *dev, void *timing)
{
DRM_DEBUG_KMS("%s\n", __FILE__);
/* TODO. */
return 0;
}
static int primary_display_power_on(struct device *dev, int mode)
{
DRM_DEBUG_KMS("%s\n", __FILE__);
/* TODO */
return 0;
}
static struct rockchip_drm_display_ops primary_display_ops = {
.type = ROCKCHIP_DISPLAY_TYPE_LCD,
.is_connected = primary_display_is_connected,
.get_panel = primary_get_panel,
.check_timing = primary_check_timing,
.power_on = primary_display_power_on,
};
static void primary_dpms(struct device *subdrv_dev, int mode)
{
struct primary_context *ctx = get_primary_context(subdrv_dev);
DRM_DEBUG_KMS("%s, %d\n", __FILE__, mode);
mutex_lock(&ctx->lock);
switch (mode) {
case DRM_MODE_DPMS_ON:
/*
* enable primary hardware only if suspended status.
*
* P.S. primary_dpms function would be called at booting time so
* clk_enable could be called double time.
*/
if (ctx->suspended)
pm_runtime_get_sync(subdrv_dev);
break;
case DRM_MODE_DPMS_STANDBY:
case DRM_MODE_DPMS_SUSPEND:
case DRM_MODE_DPMS_OFF:
if (!ctx->suspended)
pm_runtime_put_sync(subdrv_dev);
break;
default:
DRM_DEBUG_KMS("unspecified mode %d\n", mode);
break;
}
mutex_unlock(&ctx->lock);
}
static void primary_apply(struct device *subdrv_dev)
{
struct primary_context *ctx = get_primary_context(subdrv_dev);
struct rockchip_drm_manager *mgr = ctx->subdrv.manager;
struct rockchip_drm_manager_ops *mgr_ops = mgr->ops;
struct rockchip_drm_overlay_ops *ovl_ops = mgr->overlay_ops;
struct primary_win_data *win_data;
int i;
DRM_DEBUG_KMS("%s\n", __FILE__);
for (i = 0; i < WINDOWS_NR; i++) {
win_data = &ctx->win_data[i];
if (win_data->enabled && (ovl_ops && ovl_ops->commit))
ovl_ops->commit(subdrv_dev, i);
}
if (mgr_ops && mgr_ops->commit)
mgr_ops->commit(subdrv_dev);
}
static void primary_commit(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
struct rk_drm_display *drm_disp = ctx->drm_disp;
printk(KERN_ERR"%s %d\n", __func__,__LINE__);
if (ctx->suspended)
return;
drm_disp->mode_id = drm_disp->best_mode;
drm_disp->enable = true;
rk_drm_disp_handle(drm_disp,0,RK_DRM_SCREEN_SET);
}
static int primary_enable_vblank(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
DRM_DEBUG_KMS("%s\n", __FILE__);
if (ctx->suspended)
return -EPERM;
return 0;
}
static void primary_disable_vblank(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
DRM_DEBUG_KMS("%s\n", __FILE__);
if (ctx->suspended)
return;
}
static void primary_wait_for_vblank(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
if (ctx->suspended)
return;
atomic_set(&ctx->wait_vsync_event, 1);
if (!wait_event_timeout(ctx->wait_vsync_queue,
!atomic_read(&ctx->wait_vsync_event),
DRM_HZ/20))
DRM_DEBUG_KMS("vblank wait timed out.\n");
}
static void primary_event_call_back_handle(struct rk_drm_display *drm_disp,int win_id,int event)
{
struct primary_context *ctx = get_primary_context(g_dev);
struct rockchip_drm_subdrv *subdrv = &ctx->subdrv;
struct rockchip_drm_manager *manager = subdrv->manager;
struct drm_device *drm_dev = subdrv->drm_dev;
switch(event){
case RK_DRM_CALLBACK_VSYNC:
/* check the crtc is detached already from encoder */
if (manager->pipe < 0)
return;
drm_handle_vblank(drm_dev, manager->pipe);
rockchip_drm_crtc_finish_pageflip(drm_dev, manager->pipe);
/* set wait vsync event to zero and wake up queue. */
if (atomic_read(&ctx->wait_vsync_event)) {
atomic_set(&ctx->wait_vsync_event, 0);
DRM_WAKEUP(&ctx->wait_vsync_queue);
}
break;
default:
printk(KERN_ERR"-->%s unhandle event %d\n",__func__,event);
break;
}
}
static struct rockchip_drm_manager_ops primary_manager_ops = {
.dpms = primary_dpms,
.apply = primary_apply,
.commit = primary_commit,
.enable_vblank = primary_enable_vblank,
.disable_vblank = primary_disable_vblank,
.wait_for_vblank = primary_wait_for_vblank,
};
static void primary_win_mode_set(struct device *dev,
struct rockchip_drm_overlay *overlay)
{
struct primary_context *ctx = get_primary_context(dev);
struct primary_win_data *win_data;
int win;
unsigned long offset;
DRM_DEBUG_KMS("%s\n", __FILE__);
if (!overlay) {
dev_err(dev, "overlay is NULL\n");
return;
}
win = overlay->zpos;
if (win == DEFAULT_ZPOS)
win = ctx->default_win;
if (win < 0 || win > WINDOWS_NR)
return;
offset = overlay->fb_x * (overlay->bpp >> 3);
offset += overlay->fb_y * overlay->pitch;
// printk("offset = 0x%lx, pitch = %x\n", offset, overlay->pitch);
// printk("crtc_x=%d crtc_y=%d crtc_width=%d crtc_height=%d\n",overlay->crtc_x,overlay->crtc_y,overlay->crtc_width,overlay->crtc_height);
// printk("fb_width=%d fb_height=%d dma_addr=%x offset=%x\n",overlay->fb_width,overlay->fb_height,overlay->dma_addr[0],offset);
win_data = &ctx->win_data[win];
win_data->offset_x = overlay->crtc_x;
win_data->offset_y = overlay->crtc_y;
win_data->ovl_width = overlay->crtc_width;
win_data->ovl_height = overlay->crtc_height;
win_data->fb_width = overlay->fb_width;
win_data->fb_height = overlay->fb_height;
win_data->dma_addr = overlay->dma_addr[0] + offset;
win_data->bpp = overlay->bpp;
win_data->buf_offsize = (overlay->fb_width - overlay->crtc_width) *
(overlay->bpp >> 3);
win_data->line_size = overlay->crtc_width * (overlay->bpp >> 3);
}
static void primary_win_set_pixfmt(struct device *dev, unsigned int win)
{
struct primary_context *ctx = get_primary_context(dev);
struct primary_win_data *win_data = &ctx->win_data[win];
}
static void primary_win_set_colkey(struct device *dev, unsigned int win)
{
// struct primary_context *ctx = get_primary_context(dev);
DRM_DEBUG_KMS("%s\n", __FILE__);
}
static void primary_win_commit(struct device *dev, int zpos)
{
struct primary_context *ctx = get_primary_context(dev);
struct rk_drm_display *drm_disp = ctx->drm_disp;
struct rk_win_data *rk_win = NULL;
struct primary_win_data *win_data;
int win = zpos;
unsigned long val, size;
u32 xpos, ypos;
// printk(KERN_ERR"%s %d\n", __func__,__LINE__);
if (ctx->suspended)
return;
if (win == DEFAULT_ZPOS)
win = ctx->default_win;
if (win < 0 || win > WINDOWS_NR)
return;
rk_win = &drm_disp->win[win];
win_data = &ctx->win_data[win];
switch(win_data->bpp){
case 32:
rk_win->format = ARGB888;
break;
case 24:
rk_win->format = RGB888;
break;
case 16:
rk_win->format = RGB565;
break;
default:
printk("not support format %d\n",win_data->bpp);
break;
}
rk_win->xpos = win_data->offset_x;
rk_win->ypos = win_data->offset_y;
rk_win->xact = win_data->ovl_width;
rk_win->yact = win_data->ovl_height;
rk_win->xsize = win_data->ovl_width;
rk_win->ysize = win_data->ovl_height;
rk_win->xvir = win_data->fb_width;
rk_win->yrgb_addr = win_data->dma_addr;
rk_win->enabled = true;
rk_drm_disp_handle(drm_disp,1<<win,RK_DRM_WIN_COMMIT | RK_DRM_DISPLAY_COMMIT);
win_data->enabled = true;
}
static void primary_win_disable(struct device *dev, int zpos)
{
struct primary_context *ctx = get_primary_context(dev);
struct rk_drm_display *drm_disp = ctx->drm_disp;
struct primary_win_data *win_data;
int win = zpos;
DRM_DEBUG_KMS("%s\n", __FILE__);
if (win == DEFAULT_ZPOS)
win = ctx->default_win;
if (win < 0 || win > WINDOWS_NR)
return;
win_data = &ctx->win_data[win];
if (ctx->suspended) {
/* do not resume this window*/
win_data->resume = false;
return;
}
drm_disp->win[win].enabled = false;
rk_drm_disp_handle(drm_disp,1<<win,RK_DRM_WIN_COMMIT | RK_DRM_DISPLAY_COMMIT);
win_data->enabled = false;
}
static struct rockchip_drm_overlay_ops primary_overlay_ops = {
.mode_set = primary_win_mode_set,
.commit = primary_win_commit,
.disable = primary_win_disable,
};
static struct rockchip_drm_manager primary_manager = {
.pipe = -1,
.ops = &primary_manager_ops,
.overlay_ops = &primary_overlay_ops,
.display_ops = &primary_display_ops,
};
#if 0
static irqreturn_t primary_irq_handler(int irq, void *dev_id)
{
struct primary_context *ctx = (struct primary_context *)dev_id;
struct rockchip_drm_subdrv *subdrv = &ctx->subdrv;
struct drm_device *drm_dev = subdrv->drm_dev;
struct rockchip_drm_manager *manager = subdrv->manager;
u32 intr0_reg;
/* check the crtc is detached already from encoder */
if (manager->pipe < 0)
goto out;
drm_handle_vblank(drm_dev, manager->pipe);
rockchip_drm_crtc_finish_pageflip(drm_dev, manager->pipe);
/* set wait vsync event to zero and wake up queue. */
if (atomic_read(&ctx->wait_vsync_event)) {
atomic_set(&ctx->wait_vsync_event, 0);
DRM_WAKEUP(&ctx->wait_vsync_queue);
}
out:
return IRQ_HANDLED;
}
#endif
static int primary_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
{
DRM_DEBUG_KMS("%s\n", __FILE__);
/*
* enable drm irq mode.
* - with irq_enabled = 1, we can use the vblank feature.
*
* P.S. note that we wouldn't use drm irq handler but
* just specific driver own one instead because
* drm framework supports only one irq handler.
*/
drm_dev->irq_enabled = 1;
/*
* with vblank_disable_allowed = 1, vblank interrupt will be disabled
* by drm timer once a current process gives up ownership of
* vblank event.(after drm_vblank_put function is called)
*/
drm_dev->vblank_disable_allowed = 1;
/* attach this sub driver to iommu mapping if supported. */
if (is_drm_iommu_supported(drm_dev))
drm_iommu_attach_device(drm_dev, dev);
return 0;
}
static void primary_subdrv_remove(struct drm_device *drm_dev, struct device *dev)
{
DRM_DEBUG_KMS("%s\n", __FILE__);
/* detach this sub driver from iommu mapping if supported. */
if (is_drm_iommu_supported(drm_dev))
drm_iommu_detach_device(drm_dev, dev);
}
static void primary_clear_win(struct primary_context *ctx, int win)
{
u32 val;
DRM_DEBUG_KMS("%s\n", __FILE__);
}
static void primary_window_suspend(struct device *dev)
{
struct primary_win_data *win_data = NULL;
struct primary_context *ctx = get_primary_context(dev);
int i;
for (i = 0; i < WINDOWS_NR; i++) {
win_data = &ctx->win_data[i];
win_data->resume = win_data->enabled;
primary_win_disable(dev, i);
}
primary_wait_for_vblank(dev);
}
static void primary_window_resume(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
struct primary_win_data *win_data;
int i;
for (i = 0; i < WINDOWS_NR; i++) {
win_data = &ctx->win_data[i];
win_data->enabled = win_data->resume;
win_data->resume = false;
}
}
static int primary_activate(struct primary_context *ctx, bool enable)
{
struct device *dev = ctx->subdrv.dev;
struct rk_drm_display *drm_disp = ctx->drm_disp;
if (enable) {
int ret;
ctx->suspended = false;
drm_disp->enable = true;
rk_drm_disp_handle(drm_disp,0,RK_DRM_SCREEN_BLANK);
/* if vblank was enabled status, enable it again. */
if (ctx->vblank_en)
primary_enable_vblank(dev);
primary_window_resume(dev);
} else {
primary_window_suspend(dev);
drm_disp->enable = false;
rk_drm_disp_handle(drm_disp,0,RK_DRM_SCREEN_BLANK);
ctx->suspended = true;
}
return 0;
}
static int primary_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct primary_context *ctx;
struct rockchip_drm_subdrv *subdrv;
struct rockchip_drm_panel_info *panel;
struct rk_drm_display *drm_display = NULL;
int ret = -EINVAL;
DRM_DEBUG_KMS("%s\n", __FILE__);
g_dev = dev;
ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
if (!ctx)
return -ENOMEM;
panel = devm_kzalloc(dev, sizeof(struct rockchip_drm_panel_info), GFP_KERNEL);
ctx->panel = panel;
drm_display = rk_drm_get_diplay(RK_DRM_PRIMARY_SCREEN);
ctx->drm_disp = drm_display;
ctx->default_win = 0;
memcpy(&panel->timing,drm_display->mode,sizeof(struct fb_videomode));
drm_display->event_call_back = primary_event_call_back_handle;
DRM_INIT_WAITQUEUE(&ctx->wait_vsync_queue);
atomic_set(&ctx->wait_vsync_event, 0);
subdrv = &ctx->subdrv;
subdrv->dev = dev;
subdrv->manager = &primary_manager;
subdrv->probe = primary_subdrv_probe;
subdrv->remove = primary_subdrv_remove;
mutex_init(&ctx->lock);
platform_set_drvdata(pdev, ctx);
pm_runtime_enable(dev);
pm_runtime_get_sync(dev);
primary_commit(dev);
primary_activate(ctx, true);
rockchip_drm_subdrv_register(subdrv);
return 0;
}
static int primary_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct primary_context *ctx = platform_get_drvdata(pdev);
DRM_DEBUG_KMS("%s\n", __FILE__);
rockchip_drm_subdrv_unregister(&ctx->subdrv);
if (ctx->suspended)
goto out;
pm_runtime_set_suspended(dev);
pm_runtime_put_sync(dev);
out:
pm_runtime_disable(dev);
return 0;
}
#ifdef CONFIG_PM_SLEEP
static int primary_suspend(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
/*
* do not use pm_runtime_suspend(). if pm_runtime_suspend() is
* called here, an error would be returned by that interface
* because the usage_count of pm runtime is more than 1.
*/
if (!pm_runtime_suspended(dev))
return primary_activate(ctx, false);
return 0;
}
static int primary_resume(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
/*
* if entered to sleep when lcd panel was on, the usage_count
* of pm runtime would still be 1 so in this case, fimd driver
* should be on directly not drawing on pm runtime interface.
*/
if (!pm_runtime_suspended(dev)) {
int ret;
ret = primary_activate(ctx, true);
if (ret < 0)
return ret;
/*
* in case of dpms on(standby), primary_apply function will
* be called by encoder's dpms callback to update fimd's
* registers but in case of sleep wakeup, it's not.
* so primary_apply function should be called at here.
*/
primary_apply(dev);
}
return 0;
}
#endif
#ifdef CONFIG_PM_RUNTIME
static int primary_runtime_suspend(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
DRM_DEBUG_KMS("%s\n", __FILE__);
return primary_activate(ctx, false);
}
static int primary_runtime_resume(struct device *dev)
{
struct primary_context *ctx = get_primary_context(dev);
DRM_DEBUG_KMS("%s\n", __FILE__);
return primary_activate(ctx, true);
}
#endif
static const struct dev_pm_ops primary_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(primary_suspend, primary_resume)
SET_RUNTIME_PM_OPS(primary_runtime_suspend, primary_runtime_resume, NULL)
};
struct platform_driver primary_platform_driver = {
.probe = primary_probe,
.remove = primary_remove,
.driver = {
.owner = THIS_MODULE,
.name = "primary-display",
.pm = &primary_pm_ops,
},
};

34
drivers/gpu/drm/rockchip/rockchip_drm_primary.h Normal file
View File

@@ -0,0 +1,34 @@
#include "../../../video/rockchip/rk_drm_fb.h"
#define WINDOWS_NR 4
#define get_primary_context(dev) platform_get_drvdata(to_platform_device(dev))
struct primary_win_data {
unsigned int offset_x;
unsigned int offset_y;
unsigned int ovl_width;
unsigned int ovl_height;
unsigned int fb_width;
unsigned int fb_height;
unsigned int bpp;
dma_addr_t dma_addr;
unsigned int buf_offsize;
unsigned int line_size; /* bytes */
bool enabled;
bool resume;
};
struct primary_context {
struct rockchip_drm_subdrv subdrv;
int vblank_en;
struct drm_crtc *crtc;
struct rk_drm_display *drm_disp;
struct primary_win_data win_data[WINDOWS_NR];
unsigned int default_win;
bool suspended;
struct mutex lock;
wait_queue_head_t wait_vsync_queue;
atomic_t wait_vsync_event;
struct rockchip_drm_panel_info *panel;
};

1
drivers/video/Makefile
View File

@@ -153,6 +153,7 @@ obj-$(CONFIG_FB_JZ4740) += jz4740_fb.o
obj-$(CONFIG_FB_PUV3_UNIGFX) += fb-puv3.o
obj-$(CONFIG_FB_HYPERV) += hyperv_fb.o
obj-$(CONFIG_FB_ROCKCHIP) += rockchip/
obj-$(CONFIG_DRM_ROCKCHIP) += rockchip/
# Platform or fallback drivers go here
obj-$(CONFIG_FB_UVESA) += uvesafb.o

2
drivers/video/of_display_timing.c
View File

@@ -98,7 +98,7 @@ static struct display_timing *of_get_display_timing(struct device_node *np)
if (of_property_read_bool(np, "doublescan"))
dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
#if defined(CONFIG_FB_ROCKCHIP)
#if defined(CONFIG_FB_ROCKCHIP) || defined(CONFIG_DRM_ROCKCHIP)
if (!of_property_read_u32(np, "swap-rg", &val))
dt->flags |= val ? DISPLAY_FLAGS_SWAP_RG : 0;
if (!of_property_read_u32(np, "swap-gb", &val))

5
drivers/video/rockchip/Makefile
View File

@@ -1,7 +1,10 @@
obj-$(CONFIG_FB_ROCKCHIP) += rk_fb.o rkfb_sysfs.o screen/
obj-$(CONFIG_FB_ROCKCHIP) += rk_fb.o rkfb_sysfs.o screen/
obj-$(CONFIG_DRM_ROCKCHIP) += rk_drm_fb.o screen/
obj-$(CONFIG_RK_TRSM) += transmitter/
obj-$(CONFIG_DRM_ROCKCHIP) += lcdc/
obj-$(CONFIG_FB_ROCKCHIP) += lcdc/
obj-$(CONFIG_ROCKCHIP_RGA) += rga/
obj-$(CONFIG_ROCKCHIP_RGA2) += rga2/
obj-$(CONFIG_RK_HDMI) += display-sys.o hdmi/
obj-$(CONFIG_IEP) += iep/

10
drivers/video/rockchip/lcdc/Kconfig
View File

@@ -1,19 +1,19 @@
config LCDC_RK2928
tristate "rk2928 lcdc support"
depends on FB_ROCKCHIP && ARCH_RK2928
depends on (DRM_ROCKCHIP || FB_ROCKCHIP) && ARCH_RK2928
help
Driver for rk2928 lcdc .
config LCDC_RK30
tristate "rk30 lcdc support"
depends on FB_ROCKCHIP && ARCH_RK30XX
depends on (DRM_ROCKCHIP || FB_ROCKCHIP) && ARCH_RK30XX
help
Driver for rk30 lcdc .There are two lcd controllers on rk30
config LCDC_RK3066B
tristate "rk3066b lcdc support"
depends on FB_ROCKCHIP && ARCH_RK3066B
depends on (DRM_ROCKCHIP || FB_ROCKCHIP) && ARCH_RK3066B
help
Driver for rk3066b lcdc.
@@ -21,13 +21,13 @@ config LCDC_RK3066B
config LCDC_RK3188
bool "rk3188 lcdc support"
depends on FB_ROCKCHIP
depends on DRM_ROCKCHIP || FB_ROCKCHIP
help
Driver for rk3188/rk302x/rk319x lcdc.There are two lcd controllers on rk3188
config LCDC_RK3288
bool "rk3288 lcdc support"
depends on FB_ROCKCHIP
depends on DRM_ROCKCHIP || FB_ROCKCHIP
help
Driver for rk3288 lcdc.There are two lcd controllers on rk3288

776
drivers/video/rockchip/rk_drm_fb.c Executable file
View File

@@ -0,0 +1,776 @@
/*
* drivers/video/rockchip/rk_fb.c
*
* Copyright (C) ROCKCHIP, Inc.
* Author:yzq<yxj@rock-chips.com>
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/kthread.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <asm/div64.h>
#include <linux/uaccess.h>
#include <linux/rk_fb.h>
#include <linux/linux_logo.h>
#include <linux/dma-mapping.h>
#include <linux/of_gpio.h>
#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <video/of_display_timing.h>
#include <video/display_timing.h>
#include <dt-bindings/rkfb/rk_fb.h>
#endif
#include "rk_drm_fb.h"
__weak int support_uboot_display(void)
{
return 0;
}
static struct platform_device *drm_fb_pdev;
static struct rk_fb_trsm_ops *trsm_lvds_ops;
static struct rk_fb_trsm_ops *trsm_edp_ops;
static struct rk_fb_trsm_ops *trsm_mipi_ops;
int rk_fb_trsm_ops_register(struct rk_fb_trsm_ops *ops, int type)
{
switch (type) {
case SCREEN_RGB:
case SCREEN_LVDS:
case SCREEN_DUAL_LVDS:
trsm_lvds_ops = ops;
break;
case SCREEN_EDP:
trsm_edp_ops = ops;
break;
case SCREEN_MIPI:
case SCREEN_DUAL_MIPI:
trsm_mipi_ops = ops;
break;
default:
printk(KERN_WARNING "%s:un supported transmitter:%d!\n",
__func__, type);
break;
}
return 0;
}
struct rk_fb_trsm_ops *rk_fb_trsm_ops_get(int type)
{
struct rk_fb_trsm_ops *ops;
switch (type) {
case SCREEN_RGB:
case SCREEN_LVDS:
case SCREEN_DUAL_LVDS:
ops = trsm_lvds_ops;
break;
case SCREEN_EDP:
ops = trsm_edp_ops;
break;
case SCREEN_MIPI:
case SCREEN_DUAL_MIPI:
ops = trsm_mipi_ops;
break;
default:
ops = NULL;
printk(KERN_WARNING "%s:un supported transmitter:%d!\n",
__func__, type);
break;
}
return ops;
}
/* rk display power control parse from dts
*
*/
int rk_disp_pwr_ctr_parse_dt(struct rk_lcdc_driver *dev_drv)
{
struct device_node *root = of_get_child_by_name(dev_drv->dev->of_node,
"power_ctr");
struct device_node *child;
struct rk_disp_pwr_ctr_list *pwr_ctr;
struct list_head *pos;
enum of_gpio_flags flags;
u32 val = 0;
u32 debug = 0;
u32 mirror = 0;
int ret;
INIT_LIST_HEAD(&dev_drv->pwrlist_head);
if (!root) {
dev_err(dev_drv->dev, "can't find power_ctr node for lcdc%d\n",dev_drv->id);
return -ENODEV;
}
for_each_child_of_node(root, child) {
pwr_ctr = kmalloc(sizeof(struct rk_disp_pwr_ctr_list), GFP_KERNEL);
strcpy(pwr_ctr->pwr_ctr.name, child->name);
if (!of_property_read_u32(child, "rockchip,power_type", &val)) {
if (val == GPIO) {
pwr_ctr->pwr_ctr.type = GPIO;
pwr_ctr->pwr_ctr.gpio = of_get_gpio_flags(child, 0, &flags);
if (!gpio_is_valid(pwr_ctr->pwr_ctr.gpio)) {
dev_err(dev_drv->dev, "%s ivalid gpio\n", child->name);
return -EINVAL;
}
pwr_ctr->pwr_ctr.atv_val = !(flags & OF_GPIO_ACTIVE_LOW);
ret = gpio_request(pwr_ctr->pwr_ctr.gpio,child->name);
if (ret) {
dev_err(dev_drv->dev, "request %s gpio fail:%d\n",
child->name,ret);
}
} else {
pwr_ctr->pwr_ctr.type = REGULATOR;
}
};
of_property_read_u32(child, "rockchip,delay", &val);
pwr_ctr->pwr_ctr.delay = val;
list_add_tail(&pwr_ctr->list, &dev_drv->pwrlist_head);
}
of_property_read_u32(root, "rockchip,mirror", &mirror);
if (mirror == NO_MIRROR) {
dev_drv->screen0->x_mirror = 0;
dev_drv->screen0->y_mirror = 0;
} else if (mirror == X_MIRROR) {
dev_drv->screen0->x_mirror = 1;
dev_drv->screen0->y_mirror = 0;
} else if (mirror == Y_MIRROR) {
dev_drv->screen0->x_mirror = 0;
dev_drv->screen0->y_mirror = 1;
} else if(mirror == X_Y_MIRROR) {
dev_drv->screen0->x_mirror = 1;
dev_drv->screen0->y_mirror = 1;
}
of_property_read_u32(root, "rockchip,debug", &debug);
if (debug) {
list_for_each(pos, &dev_drv->pwrlist_head) {
pwr_ctr = list_entry(pos, struct rk_disp_pwr_ctr_list, list);
printk(KERN_INFO "pwr_ctr_name:%s\n"
"pwr_type:%s\n"
"gpio:%d\n"
"atv_val:%d\n"
"delay:%d\n\n",
pwr_ctr->pwr_ctr.name,
(pwr_ctr->pwr_ctr.type == GPIO) ? "gpio" : "regulator",
pwr_ctr->pwr_ctr.gpio,
pwr_ctr->pwr_ctr.atv_val,
pwr_ctr->pwr_ctr.delay);
}
}
return 0;
}
int rk_fb_video_mode_from_timing(const struct display_timing *dt,
struct rk_screen *screen)
{
screen->mode.pixclock = dt->pixelclock.typ;
screen->mode.left_margin = dt->hback_porch.typ;
screen->mode.right_margin = dt->hfront_porch.typ;
screen->mode.xres = dt->hactive.typ;
screen->mode.hsync_len = dt->hsync_len.typ;
screen->mode.upper_margin = dt->vback_porch.typ;
screen->mode.lower_margin = dt->vfront_porch.typ;
screen->mode.yres = dt->vactive.typ;
screen->mode.vsync_len = dt->vsync_len.typ;
screen->type = dt->screen_type;
screen->lvds_format = dt->lvds_format;
screen->face = dt->face;
if (dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE)
screen->pin_dclk = 1;
else
screen->pin_dclk = 0;
if(dt->flags & DISPLAY_FLAGS_HSYNC_HIGH)
screen->pin_hsync = 1;
else
screen->pin_hsync = 0;
if(dt->flags & DISPLAY_FLAGS_VSYNC_HIGH)
screen->pin_vsync = 1;
else
screen->pin_vsync = 0;
if(dt->flags & DISPLAY_FLAGS_DE_HIGH)
screen->pin_den = 1;
else
screen->pin_den = 0;
return 0;
}
int rk_fb_prase_timing_dt(struct device_node *np, struct rk_screen *screen)
{
struct display_timings *disp_timing;
struct display_timing *dt;
disp_timing = of_get_display_timings(np);
if (!disp_timing) {
pr_err("parse display timing err\n");
return -EINVAL;
}
dt = display_timings_get(disp_timing, 0);
rk_fb_video_mode_from_timing(dt, screen);
printk(KERN_ERR "dclk:%d\n"
"hactive:%d\n"
"hback_porch:%d\n"
"hfront_porch:%d\n"
"hsync_len:%d\n"
"vactive:%d\n"
"vback_porch:%d\n"
"vfront_porch:%d\n"
"vsync_len:%d\n"
"screen_type:%d\n"
"lvds_format:%d\n"
"face:%d\n",
dt->pixelclock.typ,
dt->hactive.typ,
dt->hback_porch.typ,
dt->hfront_porch.typ,
dt->hsync_len.typ,
dt->vactive.typ,
dt->vback_porch.typ,
dt->vfront_porch.typ,
dt->vsync_len.typ,
dt->screen_type,
dt->lvds_format,
dt->face);
return 0;
}
static int init_lcdc_win(struct rk_lcdc_driver *dev_drv, struct rk_lcdc_win *def_win)
{
int i;
int lcdc_win_num = dev_drv->lcdc_win_num;
for (i = 0; i < lcdc_win_num; i++) {
struct rk_lcdc_win *win = NULL;
win = kzalloc(sizeof(struct rk_lcdc_win), GFP_KERNEL);
if (!win) {
dev_err(dev_drv->dev, "kzmalloc for win fail!");
return -ENOMEM;
}
strcpy(win->name, def_win[i].name);
win->id = def_win[i].id;
win->support_3d = def_win[i].support_3d;
dev_drv->win[i] = win;
}
return 0;
}
static int init_lcdc_device_driver(struct rk_drm_screen_private *screen_priv,
struct rk_lcdc_win *def_win, int index)
{
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
struct rk_lcdc_driver *dev_drv = screen_priv->lcdc_dev_drv;
struct rk_screen *screen1 = NULL;
struct rk_screen *screen = devm_kzalloc(dev_drv->dev,
sizeof(struct rk_screen), GFP_KERNEL);
if (!screen) {
dev_err(dev_drv->dev, "malloc screen for lcdc%d fail!",
dev_drv->id);
goto fail_screen;
}
screen->screen_id = 0;
screen->lcdc_id = dev_drv->id;
dev_drv->screen0 = screen;
dev_drv->cur_screen = screen;
/* devie use one lcdc + rk61x scaler for dual display*/
if (rk_drm_priv->disp_mode == ONE_DUAL) {
screen1 = devm_kzalloc(dev_drv->dev,
sizeof(struct rk_screen), GFP_KERNEL);
if (screen1) {
dev_err(dev_drv->dev, "malloc screen1 for lcdc%d fail!",
dev_drv->id);
goto fail_screen1;
}
screen1->screen_id = 1;
screen1->lcdc_id = 1;
dev_drv->screen1 = screen1;
}
sprintf(dev_drv->name, "lcdc%d", dev_drv->id);
init_lcdc_win(dev_drv, def_win);
init_completion(&dev_drv->frame_done);
spin_lock_init(&dev_drv->cpl_lock);
mutex_init(&dev_drv->fb_win_id_mutex);
dev_drv->ops->fb_win_remap(dev_drv, FB_DEFAULT_ORDER);
dev_drv->first_frame = 1;
rk_disp_pwr_ctr_parse_dt(dev_drv);
if (dev_drv->prop == PRMRY) {
rk_fb_set_prmry_screen(screen);
rk_fb_get_prmry_screen(screen);
}
dev_drv->trsm_ops = rk_fb_trsm_ops_get(screen->type);
return 0;
fail_screen1:
devm_kfree(dev_drv->dev,screen);
fail_screen:
return -ENOMEM;
}
int rk_disp_pwr_enable(struct rk_lcdc_driver *dev_drv)
{
struct list_head *pos;
struct rk_disp_pwr_ctr_list *pwr_ctr_list;
struct pwr_ctr *pwr_ctr;
if (list_empty(&dev_drv->pwrlist_head))
return 0;
list_for_each(pos, &dev_drv->pwrlist_head) {
pwr_ctr_list = list_entry(pos, struct rk_disp_pwr_ctr_list, list);
pwr_ctr = &pwr_ctr_list->pwr_ctr;
if (pwr_ctr->type == GPIO) {
gpio_direction_output(pwr_ctr->gpio,pwr_ctr->atv_val);
mdelay(pwr_ctr->delay);
}
}
return 0;
}
int rk_fb_calc_fps(struct rk_screen * screen, u32 pixclock)
{
int x, y;
unsigned long long hz;
if (!screen) {
printk(KERN_ERR "%s:null screen!\n", __func__);
return 0;
}
x = screen->mode.xres + screen->mode.left_margin + screen->mode.right_margin +
screen->mode.hsync_len;
y = screen->mode.yres + screen->mode.upper_margin + screen->mode.lower_margin +
screen->mode.vsync_len;
hz = 1000000000000ULL; /* 1e12 picoseconds per second */
hz += (x * y) / 2;
do_div(hz, x * y); /* divide by x * y with rounding */
hz += pixclock / 2;
do_div(hz, pixclock); /* divide by pixclock with rounding */
return hz;
}
char *get_format_string(enum data_format format, char *fmt)
{
if (!fmt)
return NULL;
switch (format) {
case ARGB888:
strcpy(fmt, "ARGB888");
break;
case RGB888:
strcpy(fmt, "RGB888");
break;
case RGB565:
strcpy(fmt, "RGB565");
break;
case YUV420:
strcpy(fmt, "YUV420");
break;
case YUV422:
strcpy(fmt, "YUV422");
break;
case YUV444:
strcpy(fmt, "YUV444");
break;
case XRGB888:
strcpy(fmt, "XRGB888");
break;
case XBGR888:
strcpy(fmt, "XBGR888");
break;
case ABGR888:
strcpy(fmt, "XBGR888");
break;
default:
strcpy(fmt, "invalid");
break;
}
return fmt;
}
int rk_disp_pwr_disable(struct rk_lcdc_driver *dev_drv)
{
struct list_head *pos;
struct rk_disp_pwr_ctr_list *pwr_ctr_list;
struct pwr_ctr *pwr_ctr;
if (list_empty(&dev_drv->pwrlist_head))
return 0;
list_for_each(pos, &dev_drv->pwrlist_head) {
pwr_ctr_list = list_entry(pos, struct rk_disp_pwr_ctr_list, list);
pwr_ctr = &pwr_ctr_list->pwr_ctr;
if (pwr_ctr->type == GPIO) {
gpio_set_value(pwr_ctr->gpio,pwr_ctr->atv_val);
}
}
return 0;
}
/********************************
*check if the primary lcdc has registerd,
the primary lcdc mas register first
*********************************/
bool is_prmry_rk_lcdc_registered(void)
{
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
if (rk_drm_priv->screen_priv[0].lcdc_dev_drv)
return true;
else
return false;
}
static void rk_fb_update_regs_handler(struct kthread_work *work)
{
struct rk_lcdc_driver * dev_drv =
container_of(work, struct rk_lcdc_driver, update_regs_work);
struct rk_fb_reg_data *data, *next;
#if 0
//struct list_head saved_list;
mutex_lock(&dev_drv->update_regs_list_lock);
saved_list = dev_drv->update_regs_list;
list_replace_init(&dev_drv->update_regs_list, &saved_list);
mutex_unlock(&dev_drv->update_regs_list_lock);
list_for_each_entry_safe(data, next, &saved_list, list) {
//rk_fb_update_reg(dev_drv,data);
list_del(&data->list);
kfree(data);
}
#endif
}
static int rk_fb_wait_for_vsync_thread(void *data)
{
struct rk_lcdc_driver *dev_drv = data;
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
struct rk_drm_screen_private *drm_screen_priv = NULL;
struct rk_drm_display *drm_display = NULL;
if(dev_drv->prop == PRMRY)
drm_screen_priv = &rk_drm_priv->screen_priv[0];
else if(dev_drv->prop == EXTEND)
drm_screen_priv = &rk_drm_priv->screen_priv[1];
if(drm_screen_priv == NULL)
return -1;
drm_display = &drm_screen_priv->drm_disp;
while (!kthread_should_stop()) {
ktime_t timestamp = dev_drv->vsync_info.timestamp;
int ret = wait_event_interruptible(dev_drv->vsync_info.wait,
!ktime_equal(timestamp, dev_drv->vsync_info.timestamp) &&
(dev_drv->vsync_info.active || dev_drv->vsync_info.irq_stop));
if(!ret && drm_display->event_call_back)
drm_display->event_call_back(drm_display,0,RK_DRM_CALLBACK_VSYNC);
}
return 0;
}
int rk_fb_register(struct rk_lcdc_driver *dev_drv,
struct rk_lcdc_win *win, int id)
{
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
struct rk_drm_display *drm_display = NULL;
struct rk_win_data *win_data = NULL;
int i=0;
if (rk_drm_priv->num_screen == RK30_MAX_LCDC_SUPPORT)
return -ENXIO;
for (i = 0; i < RK_DRM_MAX_SCREEN_NUM; i++) {
if (!rk_drm_priv->screen_priv[i].lcdc_dev_drv)
break;
}
rk_drm_priv->num_screen++;
rk_drm_priv->screen_priv[i].lcdc_dev_drv = dev_drv;
rk_drm_priv->screen_priv[i].lcdc_dev_drv->id = id;
init_lcdc_device_driver(&rk_drm_priv->screen_priv[i],win,i);
drm_display = &rk_drm_priv->screen_priv[i].drm_disp;
drm_display->num_win = dev_drv->lcdc_win_num;
if(dev_drv->prop == PRMRY){
drm_display->screen_type = RK_DRM_PRIMARY_SCREEN;
drm_display->num_videomode = 1;
drm_display->best_mode = 0;
drm_display->is_connected = 1;
drm_display->mode = &dev_drv->cur_screen->mode;
printk("----->yzq mode dclk=%d\n",drm_display->mode->pixclock);
}else if(dev_drv->prop == EXTEND){
drm_display->screen_type = RK_DRM_EXTEND_SCREEN;
drm_display->num_videomode = 1;
drm_display->best_mode = 0;
drm_display->is_connected = 0;
}
if (dev_drv->prop == PRMRY) {
init_waitqueue_head(&dev_drv->vsync_info.wait);
dev_drv->vsync_info.thread = kthread_run(rk_fb_wait_for_vsync_thread,
dev_drv, "fb-vsync");
if (dev_drv->vsync_info.thread == ERR_PTR(-ENOMEM)) {
printk( "failed to run vsync thread\n");
dev_drv->vsync_info.thread = NULL;
}
dev_drv->vsync_info.active = 1;
mutex_init(&dev_drv->output_lock);
INIT_LIST_HEAD(&dev_drv->update_regs_list);
mutex_init(&dev_drv->update_regs_list_lock);
init_kthread_worker(&dev_drv->update_regs_worker);
dev_drv->update_regs_thread = kthread_run(kthread_worker_fn,
&dev_drv->update_regs_worker, "rk-fb");
if (IS_ERR(dev_drv->update_regs_thread)) {
int err = PTR_ERR(dev_drv->update_regs_thread);
dev_drv->update_regs_thread = NULL;
printk("failed to run update_regs thread\n");
return err;
}
init_kthread_work(&dev_drv->update_regs_work, rk_fb_update_regs_handler);
dev_drv->timeline = sw_sync_timeline_create("fb-timeline"); dev_drv->timeline_max = 1;
}
return 0;
}
int rk_fb_unregister(struct rk_lcdc_driver *dev_drv)
{
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
int i = 0;
return 0;
}
struct rk_drm_display *rk_drm_get_info(int screen_type)
{
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
int i=0;
for( i=0; i<rk_drm_priv->num_screen; i++){
if(rk_drm_priv->screen_priv[i].drm_disp.screen_type == screen_type)
break;
}
if(i==rk_drm_priv->num_screen){
printk("--->%s can not find match DISPLAY_TYPE %d\n",__func__,screen_type);
return NULL;
}
return &rk_drm_priv->screen_priv[i].drm_disp;
}
static int rk_drm_screen_blank(struct rk_drm_display *drm_disp)
{
// struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
struct rk_drm_screen_private *drm_screen_priv =
container_of(drm_disp, struct rk_drm_screen_private, drm_disp);
struct rk_lcdc_driver *lcdc_dev = drm_screen_priv->lcdc_dev_drv;
lcdc_dev->ops->blank(lcdc_dev, 0,drm_disp->enable?FB_BLANK_UNBLANK:FB_BLANK_NORMAL);
return 0;
}
static int rk_drm_screen_videomode_set(struct rk_drm_display *drm_disp)
{
// struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
struct rk_drm_screen_private *drm_screen_priv =
container_of(drm_disp, struct rk_drm_screen_private, drm_disp);
struct rk_lcdc_driver *lcdc_dev = drm_screen_priv->lcdc_dev_drv;
struct fb_videomode *mode = drm_disp->mode;
if(!mode){
printk(KERN_ERR"-->%s fb_video mode is NULL",__func__);
return -1;
}
if(mode != &lcdc_dev->cur_screen->mode)
memcpy(&lcdc_dev->cur_screen->mode,mode,sizeof(struct fb_videomode));
if(!lcdc_dev->atv_layer_cnt)
lcdc_dev->ops->open(lcdc_dev, 0,true);
lcdc_dev->ops->ovl_mgr(lcdc_dev, 3210, 1);
lcdc_dev->ops->load_screen(lcdc_dev,1);
return 0;
}
static int rk_drm_win_commit(struct rk_drm_display *drm_disp,unsigned int win_id)
{
// struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
struct rk_drm_screen_private *drm_screen_priv =
container_of(drm_disp, struct rk_drm_screen_private, drm_disp);
struct rk_lcdc_driver *lcdc_dev = drm_screen_priv->lcdc_dev_drv;
unsigned int i=0,j=0;
for( i=1; i < RK_DRM_WIN_MASK; i=i<<1){
if(i&win_id ){
struct rk_lcdc_win *lcdc_win = lcdc_dev->win[j];
struct rk_win_data *drm_win= &drm_disp->win[j];
if(!lcdc_win && !drm_win){
printk(KERN_ERR"---->%s can not find display win%d\n",__func__,j);
return -1;
}
lcdc_win->format = drm_win->format;
lcdc_win->area[0].xpos = drm_win->xpos;
lcdc_win->area[0].ypos = drm_win->ypos;
lcdc_win->area[0].xsize = drm_win->xsize;
lcdc_win->area[0].ysize = drm_win->ysize;
lcdc_win->area[0].xact = drm_win->xact;
lcdc_win->area[0].yact = drm_win->yact;
lcdc_win->area[0].xvir = drm_win->xvir;
lcdc_win->area[0].y_vir_stride = drm_win->xvir;
lcdc_win->area[0].smem_start = drm_win->yrgb_addr;
lcdc_win->area[0].cbr_start = drm_win->uv_addr;
lcdc_win->alpha_en = 1;
if(lcdc_win->state != drm_win->enabled){
lcdc_dev->ops->open(lcdc_dev, j,drm_win->enabled?true:false);
}
lcdc_dev->ops->set_par(lcdc_dev,j);
lcdc_dev->ops->pan_display(lcdc_dev,j);
}
j++;
}
return 0;
}
static int rk_drm_display_commit(struct rk_drm_display *drm_disp)
{
// struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
struct rk_drm_screen_private *drm_screen_priv =
container_of(drm_disp, struct rk_drm_screen_private, drm_disp);
struct rk_lcdc_driver *lcdc_dev = drm_screen_priv->lcdc_dev_drv;
lcdc_dev->ops->lcdc_reg_update(lcdc_dev);
return 0;
}
int rk_drm_disp_handle(struct rk_drm_display *drm_disp,unsigned int win_id,unsigned int cmd_id)
{
// struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
int i=0;
for( i=1; i<RK_DRM_CMD_MASK; i=i<<1){
switch(i&cmd_id){
case RK_DRM_SCREEN_SET:
rk_drm_screen_videomode_set(drm_disp);
break;
case RK_DRM_SCREEN_BLANK:
rk_drm_screen_blank(drm_disp);
break;
case RK_DRM_WIN_COMMIT:
rk_drm_win_commit(drm_disp, win_id);
break;
case RK_DRM_DISPLAY_COMMIT:
rk_drm_display_commit(drm_disp);
break;
}
}
return 0;
}
struct rk_drm_display *rk_drm_get_diplay(int screen_type)
{
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(drm_fb_pdev);
int i=0;
for( i=0; i < rk_drm_priv->num_screen; i++){
if(rk_drm_priv->screen_priv[i].drm_disp.screen_type == screen_type)
return &rk_drm_priv->screen_priv[i].drm_disp;
}
return NULL;
}
static int rk_drm_fb_probe(struct platform_device *pdev)
{
struct rk_drm_private *rk_drm_priv= NULL;
struct device_node *np = pdev->dev.of_node;
u32 mode;
if (!np) {
dev_err(&pdev->dev, "Missing device tree node.\n");
return -EINVAL;
}
rk_drm_priv= devm_kzalloc(&pdev->dev, sizeof(struct rk_drm_private), GFP_KERNEL);
if (!rk_drm_priv) {
dev_err(&pdev->dev, "kmalloc for rk_drm_priv fail!");
return -ENOMEM;
}
platform_set_drvdata(pdev, rk_drm_priv);
if (!of_property_read_u32(np, "rockchip,disp-mode", &mode)) {
rk_drm_priv->disp_mode = mode;
} else {
dev_err(&pdev->dev, "no disp-mode node found!");
return -ENODEV;
}
dev_set_name(&pdev->dev, "rockchip-drmfb");
drm_fb_pdev = pdev;
dev_info(&pdev->dev, "rockchip drm framebuffer driver probe\n");
return 0;
}
static int rk_drm_fb_remove(struct platform_device *pdev)
{
struct rk_drm_private *rk_drm_priv = platform_get_drvdata(pdev);
kfree(rk_drm_priv);
platform_set_drvdata(pdev, NULL);
return 0;
}
static void rk_drm_fb_shutdown(struct platform_device *pdev)
{
return;
}
static const struct of_device_id rk_drm_fb_dt_ids[] = {
{ .compatible = "rockchip,rk-fb", },
{}
};
static struct platform_driver rk_drm_fb_driver = {
.probe = rk_drm_fb_probe,
.remove = rk_drm_fb_remove,
.driver = {
.name = "rk-fb",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(rk_drm_fb_dt_ids),
},
.shutdown = rk_drm_fb_shutdown,
};
static int __init rk_drm_fb_init(void)
{
return platform_driver_register(&rk_drm_fb_driver);
}
static void __exit rk_drm_fb_exit(void)
{
platform_driver_unregister(&rk_drm_fb_driver);
}
fs_initcall(rk_drm_fb_init);
module_exit(rk_drm_fb_exit);

66
drivers/video/rockchip/rk_drm_fb.h Normal file
View File

@@ -0,0 +1,66 @@
#include <linux/rk_fb.h>
#define RK_DRM_WIN_MASK 0x7fff
#define RK_DRM_CMD_MASK 0x7fff
#define RK_DRM_CALLBACK_VSYNC 0x1
#define RK_DRM_SCREEN_SET 1<<0
#define RK_DRM_SCREEN_BLANK 1<<1
#define RK_DRM_WIN_COMMIT 1<<2
#define RK_DRM_DISPLAY_COMMIT 1<<3
enum drm_screen_type {
RK_DRM_PRIMARY_SCREEN = 0,
RK_DRM_EXTEND_SCREEN,
RK_DRM_MAX_SCREEN_NUM,
};
struct rk_win_data {
unsigned int win_id;
enum data_format format;
unsigned int xpos;
unsigned int ypos;
unsigned int xact;
unsigned int yact;
unsigned int xsize;
unsigned int ysize;
unsigned int xvir;
dma_addr_t yrgb_addr;
dma_addr_t uv_addr;
bool enabled;
};
struct rk_drm_display {
/***** hardware define *****/
enum drm_screen_type screen_type;
struct fb_videomode *mode;
int num_videomode;
int best_mode;
bool is_connected;
/***** user fill info *****/
int mode_id;
bool enable;
struct rk_win_data win[RK30_MAX_LAYER_SUPPORT];
int num_win;
void (*event_call_back)(struct rk_drm_display *drm_disp,int win_id,int event);
};
struct rk_drm_screen_private {
struct rk_drm_display drm_disp;
struct rk_screen screen;
struct rk_fb_trsm_ops *trsm_ops;
struct rk_lcdc_driver *lcdc_dev_drv;
};
struct rk_drm_private {
struct rk_drm_screen_private screen_priv[RK_DRM_MAX_SCREEN_NUM];
int num_screen;
int disp_mode;
};
extern struct rk_drm_display *rk_drm_get_diplay(int screen_type);
extern int rk_drm_disp_handle(struct rk_drm_display *drm_disp,unsigned int win_id,unsigned int cmd_id);

2
include/video/display_timing.h
View File

@@ -27,7 +27,7 @@ enum display_flags {
DISPLAY_FLAGS_PIXDATA_NEGEDGE = BIT(7),
DISPLAY_FLAGS_INTERLACED = BIT(8),
DISPLAY_FLAGS_DOUBLESCAN = BIT(9),
#if defined(CONFIG_FB_ROCKCHIP)
#if defined(CONFIG_FB_ROCKCHIP) || defined(CONFIG_DRM_ROCKCHIP)
DISPLAY_FLAGS_SWAP_GB = BIT(10),
DISPLAY_FLAGS_SWAP_RG = BIT(11),
DISPLAY_FLAGS_SWAP_RB = BIT(12),