[RFC][PATCH 2/2] drm/mediatek: Add DRM Driver for Mediatek SoC MT8173.

This patch is a DRM Driver for Mediatek SoC MT8173. Now support one crtc with MIPI DSI interface. We used GEM framework for buffer management and use iommu for physically non-continuous memory.

Signed-off-by: CK Hu ck.hu@mediatek.com --- drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/mediatek/Kconfig | 28 + drivers/gpu/drm/mediatek/Makefile | 13 + drivers/gpu/drm/mediatek/mediatek_drm_crtc.c | 246 ++++ drivers/gpu/drm/mediatek/mediatek_drm_crtc.h | 80 ++ drivers/gpu/drm/mediatek/mediatek_drm_crtc_main.c | 420 +++++++ drivers/gpu/drm/mediatek/mediatek_drm_ddp.c | 202 ++++ drivers/gpu/drm/mediatek/mediatek_drm_ddp.h | 23 + drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.c | 346 ++++++ drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.h | 33 + drivers/gpu/drm/mediatek/mediatek_drm_drv.c | 369 ++++++ drivers/gpu/drm/mediatek/mediatek_drm_drv.h | 37 + drivers/gpu/drm/mediatek/mediatek_drm_dsi.c | 1333 +++++++++++++++++++++ drivers/gpu/drm/mediatek/mediatek_drm_dsi.h | 71 ++ drivers/gpu/drm/mediatek/mediatek_drm_fb.c | 339 ++++++ drivers/gpu/drm/mediatek/mediatek_drm_fb.h | 43 + drivers/gpu/drm/mediatek/mediatek_drm_gem.c | 315 +++++ drivers/gpu/drm/mediatek/mediatek_drm_gem.h | 94 ++ include/uapi/drm/mediatek_drm.h | 59 + 20 files changed, 4054 insertions(+) create mode 100644 drivers/gpu/drm/mediatek/Kconfig create mode 100644 drivers/gpu/drm/mediatek/Makefile create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_crtc.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_crtc.h create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_crtc_main.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_ddp.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_ddp.h create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.h create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_drv.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_drv.h create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_dsi.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_dsi.h create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_fb.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_fb.h create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_gem.c create mode 100644 drivers/gpu/drm/mediatek/mediatek_drm_gem.h create mode 100644 include/uapi/drm/mediatek_drm.h

diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 47f2ce8..441be2d 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -217,3 +217,5 @@ source "drivers/gpu/drm/sti/Kconfig" source "drivers/gpu/drm/amd/amdkfd/Kconfig"

source "drivers/gpu/drm/imx/Kconfig" + +source "drivers/gpu/drm/mediatek/Kconfig" diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 7d4944e..55fe66c 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -67,6 +67,7 @@ obj-$(CONFIG_DRM_MSM) += msm/ obj-$(CONFIG_DRM_TEGRA) += tegra/ obj-$(CONFIG_DRM_STI) += sti/ obj-$(CONFIG_DRM_IMX) += imx/ +obj-$(CONFIG_DRM_MEDIATEK) += mediatek/ obj-y += i2c/ obj-y += panel/ obj-y += bridge/ diff --git a/drivers/gpu/drm/mediatek/Kconfig b/drivers/gpu/drm/mediatek/Kconfig new file mode 100644 index 0000000..fa581fb --- /dev/null +++ b/drivers/gpu/drm/mediatek/Kconfig @@ -0,0 +1,28 @@ +config DRM_MEDIATEK + tristate "DRM Support for Mediatek SoCs" + depends on DRM + depends on ARCH_MEDIATEK || (ARM && COMPILE_TEST) + select MTK_SMI + select DRM_PANEL + select DRM_MIPI_DSI + select DRM_PANEL_SIMPLE + select DRM_KMS_HELPER + select IOMMU_DMA + help + Choose this option if you have a Mediatek SoCs. + The module will be called mediatek-drm + This driver provides kernel mode setting and + buffer management to userspace. + +config DRM_MEDIATEK_FBDEV + bool "Enable legacy fbdev support for Mediatek DRM" + depends on DRM_MEDIATEK + select FB_SYS_FILLRECT + select FB_SYS_COPYAREA + select FB_SYS_IMAGEBLIT + select DRM_KMS_FB_HELPER + help + Choose this option if you have a need for the legacy + fbdev support. Note that this support also provides + the Linux console on top of the Mediatek DRM mode + setting driver. diff --git a/drivers/gpu/drm/mediatek/Makefile b/drivers/gpu/drm/mediatek/Makefile new file mode 100644 index 0000000..a566a83 --- /dev/null +++ b/drivers/gpu/drm/mediatek/Makefile @@ -0,0 +1,13 @@ +mediatek-drm-objs := mediatek_drm_drv.o \ + mediatek_drm_crtc.o \ + mediatek_drm_fb.o \ + mediatek_drm_gem.o \ + mediatek_drm_dsi.o \ + mediatek_drm_ddp.o \ + mediatek_drm_ddp_comp.o \ + mediatek_drm_crtc_main.o + +obj-$(CONFIG_DRM_MEDIATEK) += mediatek-drm.o + +ccflags-y += \ + -Idrivers/gpu/drm diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_crtc.c b/drivers/gpu/drm/mediatek/mediatek_drm_crtc.c new file mode 100644 index 0000000..e1437c6 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_crtc.c @@ -0,0 +1,246 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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 <drm/drm_gem.h> +#include <drm/drm_crtc_helper.h> +#include <drm/drm_plane_helper.h> +#include <linux/dma-buf.h> +#include <linux/reservation.h> + +#include "mediatek_drm_drv.h" +#include "mediatek_drm_crtc.h" +#include "mediatek_drm_fb.h" +#include "mediatek_drm_gem.h" + + +void mtk_crtc_finish_page_flip(struct mtk_drm_crtc *mtk_crtc) +{ + struct drm_device *dev = mtk_crtc->base.dev; + + drm_send_vblank_event(dev, mtk_crtc->event->pipe, mtk_crtc->event); + drm_crtc_vblank_put(&mtk_crtc->base); + mtk_crtc->event = NULL; +} + +static void mediatek_drm_crtc_pending_ovl_config(struct mtk_drm_crtc *mtk_crtc, + bool enable, unsigned int addr) +{ + if (mtk_crtc->ops && mtk_crtc->ops->ovl_layer_config) + mtk_crtc->ops->ovl_layer_config(mtk_crtc, enable, addr); +} + +static void mediatek_drm_crtc_pending_ovl_cursor_config( + struct mtk_drm_crtc *mtk_crtc, + bool enable, unsigned int addr) +{ + if (mtk_crtc->ops && mtk_crtc->ops->ovl_layer_config_cursor) + mtk_crtc->ops->ovl_layer_config_cursor(mtk_crtc, enable, addr); +} + +static int mtk_drm_crtc_page_flip(struct drm_crtc *crtc, + struct drm_framebuffer *fb, + struct drm_pending_vblank_event *event, + uint32_t page_flip_flags) +{ + struct mtk_drm_crtc *mtk_crtc = to_mtk_crtc(crtc); + struct mtk_drm_fb *mtk_fb = to_mtk_fb(fb); + struct drm_device *dev = crtc->dev; + unsigned long flags; + bool busy; + int ret; + + spin_lock_irqsave(&dev->event_lock, flags); + busy = !!mtk_crtc->event; + if (!busy) + mtk_crtc->event = event; + spin_unlock_irqrestore(&dev->event_lock, flags); + if (busy) + return -EBUSY; + + if (fb->width != crtc->mode.hdisplay || + fb->height != crtc->mode.vdisplay) { + DRM_ERROR("mtk_drm_crtc_page_flip width/height not match !!\n"); + return -EINVAL; + } + + if (event) { + ret = drm_crtc_vblank_get(crtc); + if (ret) { + DRM_ERROR("failed to acquire vblank events\n"); + return ret; + } + } + + /* + * the values related to a buffer of the drm framebuffer + * to be applied should be set at here. because these values + * first, are set to shadow registers and then to + * real registers at vsync front porch period. + */ + crtc->primary->fb = fb; + mtk_crtc->flip_buffer = to_mtk_gem_obj(mtk_fb->gem_obj[0])->buffer; + + mediatek_drm_crtc_pending_ovl_config(mtk_crtc, true, + mtk_crtc->flip_buffer->mva_addr); + + spin_lock_irqsave(&dev->event_lock, flags); + if (mtk_crtc->event) + mtk_crtc->pending_needs_vblank = true; + spin_unlock_irqrestore(&dev->event_lock, flags); + + return ret; +} + +static void mtk_drm_crtc_destroy(struct drm_crtc *crtc) +{ + drm_crtc_cleanup(crtc); +} + +static void mtk_drm_crtc_prepare(struct drm_crtc *crtc) +{ + /* drm framework doesn't check NULL. */ +} + +static void mtk_drm_crtc_commit(struct drm_crtc *crtc) +{ + /* + * when set_crtc is requested from user or at booting time, + * crtc->commit would be called without dpms call so if dpms is + * no power on then crtc->dpms should be called + * with DRM_MODE_DPMS_ON for the hardware power to be on. + */ +} + +static bool mtk_drm_crtc_mode_fixup(struct drm_crtc *crtc, + const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + /* drm framework doesn't check NULL */ + return true; +} + +static int mtk_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 mtk_drm_crtc *mtk_crtc = to_mtk_crtc(crtc); + struct drm_framebuffer *fb; + struct mtk_drm_fb *mtk_fb; + struct mtk_drm_gem_buf *buffer; + + fb = crtc->primary->fb; + mtk_fb = to_mtk_fb(fb); + + buffer = to_mtk_gem_obj(mtk_fb->gem_obj[0])->buffer; + + mediatek_drm_crtc_pending_ovl_config(mtk_crtc, true, + buffer->mva_addr); + /* + * copy the mode data adjusted by mode_fixup() into crtc->mode + * so that hardware can be seet to proper mode. + */ + memcpy(&crtc->mode, adjusted_mode, sizeof(*adjusted_mode)); + + /* Take a reference to the new fb as we're using it */ + drm_framebuffer_reference(crtc->primary->fb); + + return 0; +} + +int mtk_drm_crtc_enable_vblank(struct drm_device *drm, int pipe) +{ + struct mtk_drm_private *priv = + (struct mtk_drm_private *)drm->dev_private; + struct mtk_drm_crtc *mtk_crtc; + + if (pipe >= MAX_CRTC || pipe < 0) { + DRM_ERROR(" - %s: invalid crtc (%d)\n", __func__, pipe); + return -EINVAL; + } + + mtk_crtc = to_mtk_crtc(priv->crtc[pipe]); + + if (mtk_crtc->ops->enable_vblank) + mtk_crtc->ops->enable_vblank(mtk_crtc); + + return 0; +} + +void mtk_drm_crtc_disable_vblank(struct drm_device *drm, int pipe) +{ + struct mtk_drm_private *priv = + (struct mtk_drm_private *)drm->dev_private; + struct mtk_drm_crtc *mtk_crtc; + + if (pipe >= MAX_CRTC || pipe < 0) + DRM_ERROR(" - %s: invalid crtc (%d)\n", __func__, pipe); + + mtk_crtc = to_mtk_crtc(priv->crtc[pipe]); + if (mtk_crtc->ops->disable_vblank) + mtk_crtc->ops->disable_vblank(mtk_crtc); +} + +static void mtk_drm_crtc_disable(struct drm_crtc *crtc) +{ + struct mtk_drm_crtc *mtk_crtc = to_mtk_crtc(crtc); + + DRM_INFO("mtk_drm_crtc_disable %d\n", crtc->base.id); + + mediatek_drm_crtc_pending_ovl_config(mtk_crtc, false, 0); + mediatek_drm_crtc_pending_ovl_cursor_config(mtk_crtc, false, 0); +} + +static struct drm_crtc_funcs mediatek_crtc_funcs = { + .set_config = drm_crtc_helper_set_config, + .page_flip = mtk_drm_crtc_page_flip, + .destroy = mtk_drm_crtc_destroy, +}; + +static struct drm_crtc_helper_funcs mediatek_crtc_helper_funcs = { + .prepare = mtk_drm_crtc_prepare, + .commit = mtk_drm_crtc_commit, + .mode_fixup = mtk_drm_crtc_mode_fixup, + .mode_set = mtk_drm_crtc_mode_set, + .disable = mtk_drm_crtc_disable, +}; + +struct mtk_drm_crtc *mtk_drm_crtc_create( + struct drm_device *drm_dev, int pipe, + struct mediatek_drm_crtc_ops *ops, + void *ctx) +{ + struct mtk_drm_private *priv = + (struct mtk_drm_private *)drm_dev->dev_private; + struct mtk_drm_crtc *mtk_crtc; + + mtk_crtc = devm_kzalloc(drm_dev->dev, sizeof(*mtk_crtc), GFP_KERNEL); + if (!mtk_crtc) { + DRM_ERROR("failed to allocate mtk crtc\n"); + return ERR_PTR(-ENOMEM); + } + + mtk_crtc->pipe = pipe; + mtk_crtc->ops = ops; + mtk_crtc->ctx = ctx; + + priv->crtc[pipe] = &mtk_crtc->base; + + drm_crtc_init(drm_dev, &mtk_crtc->base, &mediatek_crtc_funcs); + drm_crtc_helper_add(&mtk_crtc->base, &mediatek_crtc_helper_funcs); + + return mtk_crtc; +} + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_crtc.h b/drivers/gpu/drm/mediatek/mediatek_drm_crtc.h new file mode 100644 index 0000000..1732927 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_crtc.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + + +#ifndef _MEDIATEL_DRM_CRTC_H_ +#define _MEDIATEL_DRM_CRTC_H_ + +#include "mediatek_drm_ddp.h" + + +#define MAX_FB_BUFFER 4 +#define DEFAULT_ZPOS -1 + +struct mtk_drm_crtc; +struct mediatek_drm_crtc_ops { + void (*dpms)(struct mtk_drm_crtc *crtc, int mode); + int (*enable_vblank)(struct mtk_drm_crtc *crtc); + void (*disable_vblank)(struct mtk_drm_crtc *crtc); + void (*ovl_layer_config)(struct mtk_drm_crtc *crtc, + bool enable, unsigned int addr); + void (*ovl_layer_config_cursor)(struct mtk_drm_crtc *crtc, + bool enable, unsigned int addr); +}; + +/* + * MediaTek specific crtc structure. + * + * @base: crtc object. + * @pipe: a crtc index created at load() with a new crtc object creation + * and the crtc object would be set to private->crtc array + * to get a crtc object corresponding to this pipe from private->crtc + * array when irq interrupt occurred. the reason of using this pipe is that + * drm framework doesn't support multiple irq yet. + * we can refer to the crtc to current hardware interrupt occurred through + * this pipe value. + */ +struct mtk_drm_crtc { + struct drm_crtc base; + + unsigned int pipe; + struct drm_pending_vblank_event *event; + struct mtk_drm_gem_buf *flip_buffer; + struct mediatek_drm_crtc_ops *ops; + void *ctx; + bool pending_needs_vblank; + + bool pending_ovl_config; + bool pending_ovl_enabled; + unsigned int pending_ovl_addr; + unsigned int pending_ovl_width; + unsigned int pending_ovl_height; + unsigned int pending_ovl_pitch; + unsigned int pending_ovl_format; + +}; + +#define to_mtk_crtc(x) container_of(x, struct mtk_drm_crtc, base) + +struct mtk_drm_crtc *mtk_drm_crtc_create( + struct drm_device *drm_dev, int pipe, + struct mediatek_drm_crtc_ops *ops, + void *ctx); +void mtk_drm_crtc_irq(struct mtk_drm_crtc *mtk_crtc); + +void mtk_crtc_finish_page_flip(struct mtk_drm_crtc *mtk_crtc); +int mtk_drm_crtc_enable_vblank(struct drm_device *drm, int pipe); +void mtk_drm_crtc_disable_vblank(struct drm_device *drm, int pipe); + +#endif + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_crtc_main.c b/drivers/gpu/drm/mediatek/mediatek_drm_crtc_main.c new file mode 100644 index 0000000..4d16620 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_crtc_main.c @@ -0,0 +1,420 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * Authors: + * YT Shen yt.shen@mediatek.com + * CK Hu ck.hu@mediatek.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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/platform_device.h> +#include <linux/clk.h> +#include <linux/of_device.h> +#include <linux/component.h> +#include <linux/pm_runtime.h> +#include "mediatek_drm_drv.h" +#include "mediatek_drm_crtc.h" +#include "mediatek_drm_gem.h" +#include "mediatek_drm_ddp_comp.h" + + +struct crtc_main_context { + struct device *dev; + struct drm_device *drm_dev; + struct mtk_drm_crtc *crtc; + int pipe; + + struct device *ddp_dev; + struct clk *ovl0_disp_clk; + struct clk *rdma0_disp_clk; + struct clk *color0_disp_clk; + struct clk *aal_disp_clk; + struct clk *ufoe_disp_clk; + struct clk *od_disp_clk; + + void __iomem *ovl0_regs; + void __iomem *rdma0_regs; + void __iomem *color0_regs; + void __iomem *aal_regs; + void __iomem *ufoe_regs; + void __iomem *od_regs; + + bool pending_ovl_config; + bool pending_ovl_enable; + unsigned int pending_ovl_addr; + unsigned int pending_ovl_width; + unsigned int pending_ovl_height; + unsigned int pending_ovl_pitch; + unsigned int pending_ovl_format; +}; + + +static int crtc_main_ctx_initialize(struct crtc_main_context *ctx, + struct drm_device *drm_dev) +{ + struct mtk_drm_private *priv; + + priv = drm_dev->dev_private; + ctx->drm_dev = drm_dev; + ctx->pipe = priv->pipe++; + + return 0; +} + +static void crtc_main_ctx_remove(struct crtc_main_context *ctx) +{ +} + +static void crtc_main_power_on(struct crtc_main_context *ctx) +{ + int ret; + + ret = clk_prepare_enable(ctx->ovl0_disp_clk); + if (ret != 0) + DRM_ERROR("clk_prepare_enable(ctx->ovl0_disp_clk) error!\n"); + + ret = clk_prepare_enable(ctx->rdma0_disp_clk); + if (ret != 0) + DRM_ERROR("clk_prepare_enable(ctx->rdma0_disp_clk) error!\n"); + + ret = clk_prepare_enable(ctx->color0_disp_clk); + if (ret != 0) + DRM_ERROR("clk_prepare_enable(ctx->color0_disp_clk) error!\n"); + + ret = clk_prepare_enable(ctx->aal_disp_clk); + if (ret != 0) + DRM_ERROR("clk_prepare_enable(ctx->aal_disp_clk) error!\n"); + + ret = clk_prepare_enable(ctx->ufoe_disp_clk); + if (ret != 0) + DRM_ERROR("clk_prepare_enable(ctx->ufoe_disp_clk) error!\n"); + + ret = clk_prepare_enable(ctx->od_disp_clk); + if (ret != 0) + DRM_ERROR("clk_prepare_enable(ctx->od_disp_clk) error!\n"); +} + +static void crtc_main_power_off(struct crtc_main_context *ctx) +{ + clk_disable_unprepare(ctx->ovl0_disp_clk); + + clk_disable_unprepare(ctx->rdma0_disp_clk); + + clk_disable_unprepare(ctx->color0_disp_clk); + + clk_disable_unprepare(ctx->aal_disp_clk); + + clk_disable_unprepare(ctx->ufoe_disp_clk); + + clk_disable_unprepare(ctx->od_disp_clk); +} + +static void crtc_main_dpms(struct mtk_drm_crtc *crtc, int mode) +{ + /* DRM_DEBUG_KMS("%s, %d\n", __FILE__, mode); */ + + switch (mode) { + case DRM_MODE_DPMS_ON: + crtc_main_power_on(crtc->ctx); + break; + case DRM_MODE_DPMS_STANDBY: + case DRM_MODE_DPMS_SUSPEND: + case DRM_MODE_DPMS_OFF: + crtc_main_power_off(crtc->ctx); + break; + default: + DRM_DEBUG_KMS("unspecified mode %d\n", mode); + break; + } +} + +static int crtc_main_enable_vblank(struct mtk_drm_crtc *crtc) +{ + struct crtc_main_context *ctx = (struct crtc_main_context *)crtc->ctx; + + mediatek_od_enable_vblank(ctx->od_regs); + + return 0; +} + +static void crtc_main_disable_vblank(struct mtk_drm_crtc *crtc) +{ + struct crtc_main_context *ctx = (struct crtc_main_context *)crtc->ctx; + + mediatek_od_disable_vblank(ctx->od_regs); +} + +static void crtc_main_ovl_layer_config(struct mtk_drm_crtc *crtc, + bool enable, unsigned int addr) +{ + struct crtc_main_context *ctx = (struct crtc_main_context *)crtc->ctx; + unsigned int pitch = 0; + + if (crtc->base.primary->fb && crtc->base.primary->fb->pitches[0]) + pitch = crtc->base.primary->fb->pitches[0]; + + ctx->pending_ovl_enable = enable; + if (enable) { + ctx->pending_ovl_addr = addr; + ctx->pending_ovl_width = crtc->base.mode.hdisplay; + ctx->pending_ovl_height = crtc->base.mode.vdisplay; + ctx->pending_ovl_pitch = pitch; + ctx->pending_ovl_format = crtc->base.primary->fb->pixel_format; + } + ctx->pending_ovl_config = true; +} + +static struct mediatek_drm_crtc_ops crtc_main_crtc_ops = { + .dpms = crtc_main_dpms, + .enable_vblank = crtc_main_enable_vblank, + .disable_vblank = crtc_main_disable_vblank, + .ovl_layer_config = crtc_main_ovl_layer_config, +}; + +static void crtc_main_irq(struct crtc_main_context *ctx) +{ + struct drm_device *dev = ctx->drm_dev; + struct mtk_drm_crtc *mtk_crtc = ctx->crtc; + unsigned long flags; + + if (ctx->pending_ovl_config) { + ctx->pending_ovl_config = false; + mediatek_ovl_layer_config(ctx->ovl0_regs, + ctx->pending_ovl_enable, + ctx->pending_ovl_addr, + ctx->pending_ovl_width, + ctx->pending_ovl_height, + ctx->pending_ovl_pitch, + ctx->pending_ovl_format); + } + + drm_handle_vblank(ctx->drm_dev, ctx->pipe); + spin_lock_irqsave(&dev->event_lock, flags); + if (mtk_crtc->pending_needs_vblank) { + mtk_crtc_finish_page_flip(mtk_crtc); + mtk_crtc->pending_needs_vblank = false; + } + spin_unlock_irqrestore(&dev->event_lock, flags); +} + +irqreturn_t crtc_main_irq_handler(int irq, void *dev_id) +{ + struct crtc_main_context *ctx = (struct crtc_main_context *)dev_id; + + mediatek_od_clear_vblank(ctx->od_regs); + + if (ctx->pipe < 0 || !ctx->drm_dev) + goto out; + + crtc_main_irq(ctx); +out: + return IRQ_HANDLED; +} + +static int crtc_main_bind(struct device *dev, struct device *master, void *data) +{ + struct crtc_main_context *ctx = dev_get_drvdata(dev); + struct drm_device *drm_dev = data; + int ret; + + ret = crtc_main_ctx_initialize(ctx, drm_dev); + if (ret) { + DRM_ERROR("crtc_main_ctx_initialize failed.\n"); + return ret; + } + + ctx->crtc = mtk_drm_crtc_create(drm_dev, ctx->pipe, + &crtc_main_crtc_ops, ctx); + + if (IS_ERR(ctx->crtc)) { + crtc_main_ctx_remove(ctx); + return PTR_ERR(ctx->crtc); + } + + DRM_INFO("mediatek_ddp_clock_on\n"); + mediatek_ddp_clock_on(ctx->ddp_dev); + + DRM_INFO("mediatek_ddp_main_path_setup\n"); + mediatek_ddp_main_path_setup(ctx->ddp_dev); + + DRM_INFO("main_disp_path_power_on\n"); + main_disp_path_power_on(ctx->ovl0_regs, ctx->rdma0_regs, + ctx->color0_regs, ctx->ufoe_regs, ctx->od_regs); + + return 0; + +} + +static void crtc_main_unbind(struct device *dev, struct device *master, + void *data) +{ + struct crtc_main_context *ctx = dev_get_drvdata(dev); + + crtc_main_ctx_remove(ctx); +} + +static const struct component_ops crtc_main_component_ops = { + .bind = crtc_main_bind, + .unbind = crtc_main_unbind, +}; + +static int crtc_main_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct crtc_main_context *ctx; + struct device_node *node; + struct platform_device *ddp_pdev; + struct resource *regs; + int irq; + int ret; + + if (!dev->of_node) + return -ENODEV; + + ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + node = of_parse_phandle(dev->of_node, "ddp", 0); + if (!node) { + dev_err(dev, "crtc_main_probe: Get ddp node fail.\n"); + ret = -EINVAL; + goto err; + } + + ddp_pdev = of_find_device_by_node(node); + if (WARN_ON(!ddp_pdev)) { + dev_err(dev, "crtc_main_probe: Find ddp device fail.\n"); + ret = -EINVAL; + goto err; + } + ctx->ddp_dev = &ddp_pdev->dev; + + ctx->ovl0_disp_clk = devm_clk_get(dev, "ovl0_disp"); + if (IS_ERR(ctx->ovl0_disp_clk)) { + dev_err(dev, "crtc_main_probe: Get ovl0_disp_clk fail.\n"); + ret = PTR_ERR(ctx->ovl0_disp_clk); + goto err; + } + + ctx->rdma0_disp_clk = devm_clk_get(dev, "rdma0_disp"); + if (IS_ERR(ctx->rdma0_disp_clk)) { + dev_err(dev, "crtc_main_probe: Get rdma0_disp_clk.\n"); + ret = PTR_ERR(ctx->rdma0_disp_clk); + goto err; + } + + ctx->color0_disp_clk = devm_clk_get(dev, "color0_disp"); + if (IS_ERR(ctx->color0_disp_clk)) { + dev_err(dev, "crtc_main_probe: Get color0_disp_clk fail.\n"); + ret = PTR_ERR(ctx->color0_disp_clk); + goto err; + } + + ctx->aal_disp_clk = devm_clk_get(dev, "aal_disp"); + if (IS_ERR(ctx->aal_disp_clk)) { + dev_err(dev, "crtc_main_probe: Get aal_disp_clk fail.\n"); + ret = PTR_ERR(ctx->aal_disp_clk); + goto err; + } + + ctx->ufoe_disp_clk = devm_clk_get(dev, "ufoe_disp"); + if (IS_ERR(ctx->ufoe_disp_clk)) { + dev_err(dev, "crtc_main_probe: Get ufoe_disp_clk fail.\n"); + ret = PTR_ERR(ctx->ufoe_disp_clk); + goto err; + } + + ctx->od_disp_clk = devm_clk_get(dev, "od_disp"); + if (IS_ERR(ctx->od_disp_clk)) { + dev_err(dev, "crtc_main_probe: Get od_disp_clk fail.\n"); + ret = PTR_ERR(ctx->od_disp_clk); + goto err; + } + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); + ctx->ovl0_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ctx->ovl0_regs)) + return PTR_ERR(ctx->ovl0_regs); + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 1); + ctx->rdma0_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ctx->rdma0_regs)) + return PTR_ERR(ctx->rdma0_regs); + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 2); + ctx->color0_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ctx->color0_regs)) + return PTR_ERR(ctx->color0_regs); + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 3); + ctx->aal_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ctx->aal_regs)) + return PTR_ERR(ctx->aal_regs); + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 4); + ctx->ufoe_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ctx->ufoe_regs)) + return PTR_ERR(ctx->ufoe_regs); + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 5); + ctx->od_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ctx->od_regs)) + return PTR_ERR(ctx->od_regs); + + irq = platform_get_irq(pdev, 0); + ret = devm_request_irq(dev, irq, crtc_main_irq_handler, + IRQF_TRIGGER_NONE, dev_name(dev), ctx); + if (ret < 0) { + dev_err(dev, "devm_request_irq %d fail %d\n", irq, ret); + ret = -ENXIO; + goto err; + } + + platform_set_drvdata(pdev, ctx); + + ret = component_add(&pdev->dev, &crtc_main_component_ops); + if (ret) + goto err; + + return 0; + +err: + if (node) + of_node_put(node); + + return ret; +} + +static int crtc_main_remove(struct platform_device *pdev) +{ + component_del(&pdev->dev, &crtc_main_component_ops); + + return 0; +} + +static const struct of_device_id crtc_main_driver_dt_match[] = { + { .compatible = "mediatek,mt8173-crtc-main" }, + {}, +}; +MODULE_DEVICE_TABLE(of, crtc_main_driver_dt_match); + +struct platform_driver mediatek_crtc_main_driver = { + .probe = crtc_main_probe, + .remove = crtc_main_remove, + .driver = { + .name = "mediatek-crtc-main", + .owner = THIS_MODULE, + .of_match_table = crtc_main_driver_dt_match, + }, +}; + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_ddp.c b/drivers/gpu/drm/mediatek/mediatek_drm_ddp.c new file mode 100644 index 0000000..bb6959b --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_ddp.c @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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/platform_device.h> +#include <linux/clk.h> +#include <linux/pm_runtime.h> +#include <linux/of_device.h> +#include <linux/component.h> + +#include "mediatek_drm_crtc.h" +#include "mediatek_drm_ddp.h" + + +#define DISP_REG_CONFIG_DISP_OVL0_MOUT_EN 0x040 +#define DISP_REG_CONFIG_DISP_OVL1_MOUT_EN 0x044 +#define DISP_REG_CONFIG_DISP_OD_MOUT_EN 0x048 +#define DISP_REG_CONFIG_DISP_GAMMA_MOUT_EN 0x04C +#define DISP_REG_CONFIG_DISP_UFOE_MOUT_EN 0x050 +#define DISP_REG_CONFIG_DISP_COLOR0_SEL_IN 0x084 +#define DISP_REG_CONFIG_DISP_COLOR1_SEL_IN 0x088 +#define DISP_REG_CONFIG_DPI_SEL_IN 0x0AC +#define DISP_REG_CONFIG_DISP_PATH1_SOUT_SEL_IN 0x0C8 +#define DISP_REG_CONFIG_MMSYS_CG_CON0 0x100 + +#define DISP_REG_CONFIG_MUTEX_EN(n) (0x20 + 0x20 * n) +#define DISP_REG_CONFIG_MUTEX_MOD(n) (0x2C + 0x20 * n) +#define DISP_REG_CONFIG_MUTEX_SOF(n) (0x30 + 0x20 * n) + + +enum { + MUTEX_MOD_OVL0 = 11, + MUTEX_MOD_RDMA0 = 13, + MUTEX_MOD_COLOR0 = 18, + MUTEX_MOD_AAL = 20, + MUTEX_MOD_UFOE = 22, + MUTEX_MOD_PWM0 = 23, + MUTEX_MOD_OD = 25, +}; + +enum { + MUTEX_SOF_DSI0 = 1, +}; + +enum { + OVL0_MOUT_EN_COLOR0 = 0x1, +}; + +enum { + OD_MOUT_EN_RDMA0 = 0x1, +}; + +enum { + UFOE_MOUT_EN_DSI0 = 0x1, +}; + +enum { + COLOR0_SEL_IN_OVL0 = 0x1, +}; + +struct ddp_context { + struct device *dev; + struct drm_device *drm_dev; + struct mediatek_drm_crtc *crtc; + int pipe; + + struct clk *mutex_disp_clk; + + void __iomem *config_regs; + void __iomem *mutex_regs; + + bool pending_ovl_config; + bool pending_ovl_enable; + unsigned int pending_ovl_addr; + unsigned int pending_ovl_width; + unsigned int pending_ovl_height; + unsigned int pending_ovl_pitch; + unsigned int pending_ovl_format; +}; + + +static void disp_config_main_path_connection(void __iomem *disp_base) +{ + writel(OVL0_MOUT_EN_COLOR0, + disp_base + DISP_REG_CONFIG_DISP_OVL0_MOUT_EN); + writel(OD_MOUT_EN_RDMA0, disp_base + DISP_REG_CONFIG_DISP_OD_MOUT_EN); + writel(UFOE_MOUT_EN_DSI0, + disp_base + DISP_REG_CONFIG_DISP_UFOE_MOUT_EN); + writel(COLOR0_SEL_IN_OVL0, + disp_base + DISP_REG_CONFIG_DISP_COLOR0_SEL_IN); +} + +static void disp_config_main_path_mutex(void __iomem *mutex_base) +{ + unsigned int id = 0; + + writel((1 << MUTEX_MOD_OVL0 | 1 << MUTEX_MOD_RDMA0 | + 1 << MUTEX_MOD_COLOR0 | 1 << MUTEX_MOD_AAL | + 1 << MUTEX_MOD_UFOE | 1 << MUTEX_MOD_PWM0 | + 1 << MUTEX_MOD_OD), + mutex_base + DISP_REG_CONFIG_MUTEX_MOD(id)); + + writel(MUTEX_SOF_DSI0, mutex_base + DISP_REG_CONFIG_MUTEX_SOF(id)); + writel(1, mutex_base + DISP_REG_CONFIG_MUTEX_EN(id)); +} + +void mediatek_ddp_main_path_setup(struct device *dev) +{ + struct ddp_context *ddp = dev_get_drvdata(dev); + + disp_config_main_path_connection(ddp->config_regs); + disp_config_main_path_mutex(ddp->mutex_regs); +} + +void mediatek_ddp_clock_on(struct device *dev) +{ + struct ddp_context *ddp = dev_get_drvdata(dev); + int ret; + + /* disp_mtcmos */ + ret = pm_runtime_get_sync(dev); + if (ret < 0) + DRM_ERROR("failed to get_sync(%d)\n", ret); + + ret = clk_prepare_enable(ddp->mutex_disp_clk); + if (ret != 0) + DRM_ERROR("clk_prepare_enable(mutex_disp_clk) error!\n"); +} + +static int ddp_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct ddp_context *ddp; + struct resource *regs; + int ret; + + if (!dev->of_node) + return -ENODEV; + + ddp = devm_kzalloc(dev, sizeof(*ddp), GFP_KERNEL); + if (!ddp) + return -ENOMEM; + + ddp->mutex_disp_clk = devm_clk_get(dev, "mutex_disp"); + if (IS_ERR(ddp->mutex_disp_clk)) { + dev_err(dev, "ddp_probe: Get mutex_disp_clk fail.\n"); + ret = PTR_ERR(ddp->mutex_disp_clk); + goto err; + } + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); + ddp->config_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ddp->config_regs)) + return PTR_ERR(ddp->config_regs); + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 1); + ddp->mutex_regs = devm_ioremap_resource(dev, regs); + if (IS_ERR(ddp->mutex_regs)) + return PTR_ERR(ddp->mutex_regs); + + platform_set_drvdata(pdev, ddp); + + pm_runtime_enable(dev); + + return 0; + +err: + + return ret; +} + +static int ddp_remove(struct platform_device *pdev) +{ + return 0; +} + +static const struct of_device_id ddp_driver_dt_match[] = { + { .compatible = "mediatek,mt8173-ddp" }, + {}, +}; +MODULE_DEVICE_TABLE(of, ddp_driver_dt_match); + +struct platform_driver mediatek_ddp_driver = { + .probe = ddp_probe, + .remove = ddp_remove, + .driver = { + .name = "mediatek-ddp", + .owner = THIS_MODULE, + .of_match_table = ddp_driver_dt_match, + }, +}; + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_ddp.h b/drivers/gpu/drm/mediatek/mediatek_drm_ddp.h new file mode 100644 index 0000000..07dd637 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_ddp.h @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + +#ifndef _MEDIATEK_DRM_DDP_H_ +#define _MEDIATEK_DRM_DDP_H_ + +void mediatek_ddp_main_path_setup(struct device *dev); + +void mediatek_ddp_clock_on(struct device *dev); + + +#endif + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.c b/drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.c new file mode 100644 index 0000000..dd7ac83 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.c @@ -0,0 +1,346 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * Authors: + * YT Shen yt.shen@mediatek.com + * CK Hu ck.hu@mediatek.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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/clk.h> + + +#define DISP_REG_OVL_INTEN 0x0004 +#define DISP_REG_OVL_INTSTA 0x0008 +#define DISP_REG_OVL_EN 0x000C +#define DISP_REG_OVL_RST 0x0014 +#define DISP_REG_OVL_ROI_SIZE 0x0020 +#define DISP_REG_OVL_ROI_BGCLR 0x0028 +#define DISP_REG_OVL_SRC_CON 0x002C +#define DISP_REG_OVL_L0_CON 0x0030 +#define DISP_REG_OVL_L0_SRCKEY 0x0034 +#define DISP_REG_OVL_L0_SRC_SIZE 0x0038 +#define DISP_REG_OVL_L0_OFFSET 0x003C +#define DISP_REG_OVL_L0_PITCH 0x0044 +#define DISP_REG_OVL_L1_CON 0x0050 +#define DISP_REG_OVL_L1_SRCKEY 0x0054 +#define DISP_REG_OVL_L1_SRC_SIZE 0x0058 +#define DISP_REG_OVL_L1_OFFSET 0x005C +#define DISP_REG_OVL_L1_PITCH 0x0064 +#define DISP_REG_OVL_RDMA0_CTRL 0x00C0 +#define DISP_REG_OVL_RDMA0_MEM_GMC_SETTING 0x00C8 +#define DISP_REG_OVL_RDMA1_CTRL 0x00E0 +#define DISP_REG_OVL_RDMA1_MEM_GMC_SETTING 0x00E8 +#define DISP_REG_OVL_RDMA1_FIFO_CTRL 0x00F0 +#define DISP_REG_OVL_L0_ADDR 0x0f40 +#define DISP_REG_OVL_L1_ADDR 0x0f60 + +#define DISP_REG_RDMA_INT_ENABLE 0x0000 +#define DISP_REG_RDMA_INT_STATUS 0x0004 +#define DISP_REG_RDMA_GLOBAL_CON 0x0010 +#define DISP_REG_RDMA_SIZE_CON_0 0x0014 +#define DISP_REG_RDMA_SIZE_CON_1 0x0018 +#define DISP_REG_RDMA_FIFO_CON 0x0040 + +#define DISP_OD_EN 0x000 +#define DISP_OD_INTEN 0x008 +#define DISP_OD_INTS 0x00C +#define DISP_OD_CFG 0x020 +#define DISP_OD_SIZE 0x030 + +#define DISP_REG_UFO_START 0x000 + +#define DISP_COLOR_CFG_MAIN 0x400 +#define DISP_COLOR_START 0xC00 + +enum DISPLAY_PATH { + PRIMARY_PATH = 0, + EXTERNAL_PATH = 1, +}; + +enum RDMA_MODE { + RDMA_MODE_DIRECT_LINK = 0, + RDMA_MODE_MEMORY = 1, +}; + +enum RDMA_OUTPUT_FORMAT { + RDMA_OUTPUT_FORMAT_ARGB = 0, + RDMA_OUTPUT_FORMAT_YUV444 = 1, +}; + +#define OVL_COLOR_BASE 30 +enum OVL_INPUT_FORMAT { + OVL_INFMT_RGB565 = 0, + OVL_INFMT_RGB888 = 1, + OVL_INFMT_RGBA8888 = 2, + OVL_INFMT_ARGB8888 = 3, + OVL_INFMT_UYVY = 4, + OVL_INFMT_YUYV = 5, + OVL_INFMT_UNKNOWN = 16, + + OVL_INFMT_BGR565 = OVL_INFMT_RGB565 + OVL_COLOR_BASE, + OVL_INFMT_BGR888 = OVL_INFMT_RGB888 + OVL_COLOR_BASE, + OVL_INFMT_BGRA8888 = OVL_INFMT_RGBA8888 + OVL_COLOR_BASE, + OVL_INFMT_ABGR8888 = OVL_INFMT_ARGB8888 + OVL_COLOR_BASE, +}; + +enum { + OD_RELAY_MODE = 0x1, +}; + +enum { + UFO_BYPASS = 0x4, +}; + +enum { + COLOR_BYPASS_ALL = (1UL<<7), + COLOR_SEQ_SEL = (1UL<<13), +}; + +enum { + OVL_LAYER_SRC_DRAM = 0, +}; + + +static void mediatek_ovl_start(void __iomem *ovl_base) +{ + writel(0x01, ovl_base + DISP_REG_OVL_EN); +} + +static void mediatek_ovl_roi(void __iomem *ovl_base, + unsigned int w, unsigned int h, unsigned int bg_color) +{ + writel(h << 16 | w, ovl_base + DISP_REG_OVL_ROI_SIZE); + writel(bg_color, ovl_base + DISP_REG_OVL_ROI_BGCLR); +} + +void mediatek_ovl_layer_switch(void __iomem *ovl_base, + unsigned layer, bool en) +{ + u32 reg; + + reg = readl(ovl_base + DISP_REG_OVL_SRC_CON); + if (en) + reg |= (1U<<layer); + else + reg &= ~(1U<<layer); + + writel(reg, ovl_base + DISP_REG_OVL_SRC_CON); + writel(0x1, ovl_base + DISP_REG_OVL_RST); + writel(0x0, ovl_base + DISP_REG_OVL_RST); +} + +static unsigned int ovl_fmt_convert(unsigned int fmt) +{ + switch (fmt) { + case DRM_FORMAT_RGB888: + return OVL_INFMT_RGB888; + case DRM_FORMAT_RGB565: + return OVL_INFMT_RGB565; + case DRM_FORMAT_ARGB8888: + return OVL_INFMT_ARGB8888; + case DRM_FORMAT_RGBA8888: + return OVL_INFMT_RGBA8888; + case DRM_FORMAT_BGR888: + return OVL_INFMT_BGR888; + case DRM_FORMAT_BGR565: + return OVL_INFMT_BGR565; + case DRM_FORMAT_ABGR8888: + return OVL_INFMT_ABGR8888; + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_BGRA8888: + return OVL_INFMT_BGRA8888; + case DRM_FORMAT_YUYV: + return OVL_INFMT_YUYV; + case DRM_FORMAT_UYVY: + return OVL_INFMT_UYVY; + default: + return OVL_INFMT_UNKNOWN; + } +} + +void mediatek_ovl_layer_config(void __iomem *ovl_base, bool enabled, + unsigned int addr, unsigned int width, unsigned int height, + unsigned int pitch, unsigned int format) +{ + unsigned int reg; + unsigned int dst_x = 0; + unsigned int dst_y = 0; + bool color_key_en = 1; + unsigned int color_key = 0xFF000000; + bool alpha_en = 0; + unsigned char alpha = 0x0; + unsigned int src_con, new_set; + + unsigned int rgb_swap, bpp; + unsigned int fmt = ovl_fmt_convert(format); + + if (fmt == OVL_INFMT_BGR888 || fmt == OVL_INFMT_BGR565 || + fmt == OVL_INFMT_ABGR8888 || fmt == OVL_INFMT_BGRA8888) { + fmt -= OVL_COLOR_BASE; + rgb_swap = 1; + } else { + rgb_swap = 0; + } + + switch (fmt) { + case OVL_INFMT_ARGB8888: + case OVL_INFMT_RGBA8888: + bpp = 4; + break; + case OVL_INFMT_RGB888: + bpp = 3; + break; + case OVL_INFMT_RGB565: + case OVL_INFMT_YUYV: + case OVL_INFMT_UYVY: + bpp = 2; + break; + default: + bpp = 1; + } + + if (pitch == 0) + pitch = width * bpp; + + src_con = readl(ovl_base + DISP_REG_OVL_SRC_CON); + if (enabled == true) + new_set = src_con | 0x1; + else + new_set = src_con & ~(0x1); + + writel(0x1, ovl_base + DISP_REG_OVL_RST); + writel(0x0, ovl_base + DISP_REG_OVL_RST); + + writel(new_set, ovl_base + DISP_REG_OVL_SRC_CON); + + writel(0x00000001, ovl_base + DISP_REG_OVL_RDMA0_CTRL); + writel(0x40402020, ovl_base + DISP_REG_OVL_RDMA0_MEM_GMC_SETTING); + + reg = color_key_en << 30 | OVL_LAYER_SRC_DRAM << 28 | + rgb_swap << 25 | fmt << 12 | alpha_en << 8 | alpha; + writel(reg, ovl_base + DISP_REG_OVL_L0_CON); + writel(color_key, ovl_base + DISP_REG_OVL_L0_SRCKEY); + writel(height << 16 | width, ovl_base + DISP_REG_OVL_L0_SRC_SIZE); + writel(dst_y << 16 | dst_x, ovl_base + DISP_REG_OVL_L0_OFFSET); + writel(addr, ovl_base + DISP_REG_OVL_L0_ADDR); + writel(pitch & 0xFFFF, ovl_base + DISP_REG_OVL_L0_PITCH); +} + +static void mediatek_rdma_start(void __iomem *rdma_base) +{ + unsigned int reg; + + writel(0x4, rdma_base + DISP_REG_RDMA_INT_ENABLE); + reg = readl(rdma_base + DISP_REG_RDMA_GLOBAL_CON); + reg |= 1; + writel(reg, rdma_base + DISP_REG_RDMA_GLOBAL_CON); +} + +static void mediatek_rdma_config_direct_link(void __iomem *rdma_base, + unsigned width, unsigned height) +{ + unsigned int reg; + enum RDMA_MODE mode = RDMA_MODE_DIRECT_LINK; + enum RDMA_OUTPUT_FORMAT output_format = RDMA_OUTPUT_FORMAT_ARGB; + + reg = readl(rdma_base + DISP_REG_RDMA_GLOBAL_CON); + if (mode == RDMA_MODE_DIRECT_LINK) + reg &= ~(0x2U); + writel(reg, rdma_base + DISP_REG_RDMA_GLOBAL_CON); + + reg = readl(rdma_base + DISP_REG_RDMA_SIZE_CON_0); + if (output_format == RDMA_OUTPUT_FORMAT_ARGB) + reg &= ~(0x20000000U); + else + reg |= 0x20000000U; + writel(reg, rdma_base + DISP_REG_RDMA_SIZE_CON_0); + + reg = readl(rdma_base + DISP_REG_RDMA_SIZE_CON_0); + reg = (reg & ~(0xFFFU)) | (width & 0xFFFU); + writel(reg, rdma_base + DISP_REG_RDMA_SIZE_CON_0); + + reg = readl(rdma_base + DISP_REG_RDMA_SIZE_CON_1); + reg = (reg & ~(0xFFFFFU)) | (height & 0xFFFFFU); + writel(reg, rdma_base + DISP_REG_RDMA_SIZE_CON_1); + + writel(0x80F00008, rdma_base + DISP_REG_RDMA_FIFO_CON); +} + +void mediatek_od_enable_vblank(void __iomem *disp_base) +{ + writel(0x1, disp_base + DISP_OD_INTEN); +} + +void mediatek_od_disable_vblank(void __iomem *disp_base) +{ + writel(0x0, disp_base + DISP_OD_INTEN); +} + +void mediatek_od_clear_vblank(void __iomem *disp_base) +{ + writel(0x0, disp_base + DISP_OD_INTS); +} + +static void mediatek_od_start(void __iomem *od_base, unsigned int w, + unsigned int h) +{ + writel(w << 16 | h, od_base + DISP_OD_SIZE); + writel(OD_RELAY_MODE, od_base + DISP_OD_CFG); + writel(1, od_base + DISP_OD_EN); +} + +static void mediatek_ufoe_start(void __iomem *ufoe_base) +{ + writel(UFO_BYPASS, ufoe_base + DISP_REG_UFO_START); +} + +static void mediatek_color_start(void __iomem *color_base) +{ + writel(COLOR_BYPASS_ALL | COLOR_SEQ_SEL, + color_base + DISP_COLOR_CFG_MAIN); + writel(0x1, color_base + DISP_COLOR_START); +} + +void main_disp_path_power_on(void __iomem *ovl_base, + void __iomem *rdma_base, + void __iomem *color_base, + void __iomem *ufoe_base, + void __iomem *od_base) +{ + struct device_node *node; + unsigned int width, height; + int err; + + node = of_find_compatible_node(NULL, NULL, "mediatek,mt8173-dsi"); + + err = of_property_read_u32(node, "mediatek,width", &width); + if (err < 0) + return; + + err = of_property_read_u32(node, "mediatek,height", &height); + if (err < 0) + return; + + width = ((width + 3)>>2)<<2; + + mediatek_ovl_start(ovl_base); + mediatek_rdma_start(rdma_base); + + mediatek_ovl_roi(ovl_base, width, height, 0x00000000); + mediatek_ovl_layer_switch(ovl_base, 0, 1); + mediatek_rdma_config_direct_link(rdma_base, width, height); + mediatek_od_start(od_base, width, height); + mediatek_ufoe_start(ufoe_base); + mediatek_color_start(color_base); +} + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.h b/drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.h new file mode 100644 index 0000000..d3ed3e1 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_ddp_comp.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + +#ifndef _MEDIATEK_DRM_DDP_COMP_H_ +#define _MEDIATEK_DRM_DDP_COMP_H_ + + +void mediatek_od_enable_vblank(void __iomem *drm_disp_base); +void mediatek_od_disable_vblank(void __iomem *drm_disp_base); +void mediatek_od_clear_vblank(void __iomem *drm_disp_base); +void mediatek_ovl_layer_config(void __iomem *ovl_base, bool enabled, + unsigned int addr, unsigned int width, unsigned int height, + unsigned int pitch, unsigned int format); + +void main_disp_path_power_on(void __iomem *ovl_base, + void __iomem *rdma_base, void __iomem *color_base, + void __iomem *ufoe_base, void __iomem *od_base); + +void mediatek_ovl_layer_switch(void __iomem *ovl_base, + unsigned layer, bool en); + +#endif + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_drv.c b/drivers/gpu/drm/mediatek/mediatek_drm_drv.c new file mode 100644 index 0000000..dfd816f --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_drv.c @@ -0,0 +1,369 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * Author: YT SHEN yt.shen@mediatek.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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 <drm/drm_gem.h> +#include <drm/drm_crtc.h> +#include <drm/drm_crtc_helper.h> +#include <linux/of_platform.h> +#include <linux/component.h> +#include <linux/mtk-smi.h> +#include <linux/pm_runtime.h> +#include <linux/dma-iommu.h> + +#include "mediatek_drm_drv.h" +#include "mediatek_drm_crtc.h" +#include "mediatek_drm_fb.h" +#include "mediatek_drm_gem.h" + +#include "drm/mediatek_drm.h" + +#define DRIVER_NAME "mediatek" +#define DRIVER_DESC "Mediatek SoC DRM" +#define DRIVER_DATE "20150513" +#define DRIVER_MAJOR 1 +#define DRIVER_MINOR 0 + +static struct drm_mode_config_funcs mediatek_drm_mode_config_funcs = { + .fb_create = mtk_drm_mode_fb_create, + .output_poll_changed = mtk_drm_mode_output_poll_changed, +}; + +static int mtk_drm_kms_init(struct drm_device *dev) +{ + struct device_node *node; + struct platform_device *pdev; + int err; + + drm_mode_config_init(dev); + + dev->mode_config.min_width = 640; + dev->mode_config.min_height = 480; + + /* + * set max width and height as default value(4096x4096). + * this value would be used to check framebuffer size limitation + * at drm_mode_addfb(). + */ + dev->mode_config.max_width = 4096; + dev->mode_config.max_height = 4096; + dev->mode_config.funcs = &mediatek_drm_mode_config_funcs; + + err = component_bind_all(dev->dev, dev); + if (err) + goto err_crtc; + + /* + * We don't use the drm_irq_install() helpers provided by the DRM + * core, so we need to set this manually in order to allow the + * DRM_IOCTL_WAIT_VBLANK to operate correctly. + */ + dev->irq_enabled = true; + err = drm_vblank_init(dev, MAX_CRTC); + if (err < 0) + goto err_crtc; + + drm_kms_helper_poll_init(dev); + + node = of_parse_phandle(dev->dev->of_node, "iommus", 0); + if (!node) + return 0; + + pdev = of_find_device_by_node(node); + if (WARN_ON(!pdev)) { + of_node_put(node); + return -EINVAL; + } + err = iommu_dma_attach_device(dev->dev, + arch_get_dma_domain(&pdev->dev)); + if (err) + DRM_ERROR("iommu_dma_attach_device fail %d\n", err); + + node = of_parse_phandle(dev->dev->of_node, "larb", 0); + if (!node) + return 0; + + pdev = of_find_device_by_node(node); + if (WARN_ON(!pdev)) { + of_node_put(node); + return -EINVAL; + } + + err = mtk_smi_larb_get(&pdev->dev); + if (err) + DRM_ERROR("mtk_smi_larb_get fail %d\n", err); + + node = of_parse_phandle(dev->dev->of_node, "larb", 1); + if (!node) + return 0; + + pdev = of_find_device_by_node(node); + if (WARN_ON(!pdev)) { + of_node_put(node); + return -EINVAL; + } + + err = mtk_smi_larb_get(&pdev->dev); + if (err) + DRM_ERROR("mtk_smi_larb_get fail %d\n", err); + + mtk_fbdev_create(dev); + + return 0; +err_crtc: + drm_mode_config_cleanup(dev); + + return err; +} + +static int mtk_drm_load(struct drm_device *dev, unsigned long flags) +{ + struct mtk_drm_private *priv; + + priv = devm_kzalloc(dev->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + dev->dev_private = priv; + platform_set_drvdata(dev->platformdev, dev); + + return mtk_drm_kms_init(dev); +} + +static void mtk_drm_kms_deinit(struct drm_device *dev) +{ + drm_kms_helper_poll_fini(dev); + + mtk_fbdev_destroy(dev); + + drm_vblank_cleanup(dev); + drm_mode_config_cleanup(dev); + + pm_runtime_disable(dev->dev); +} + +static int mtk_drm_unload(struct drm_device *dev) +{ + mtk_drm_kms_deinit(dev); + dev->dev_private = NULL; + + return 0; +} + +static int mtk_drm_open(struct drm_device *drm, struct drm_file *filp) +{ + return 0; +} + +static void mediatek_drm_preclose(struct drm_device *drm, struct drm_file *file) +{ +} + +static void mediatek_drm_lastclose(struct drm_device *drm) +{ +} + +static const struct vm_operations_struct mediatek_drm_gem_vm_ops = { + .open = drm_gem_vm_open, + .close = drm_gem_vm_close, +}; + +static const struct drm_ioctl_desc mtk_ioctls[] = { + DRM_IOCTL_DEF_DRV(MTK_GEM_CREATE, mediatek_gem_create_ioctl, + DRM_UNLOCKED | DRM_AUTH), + DRM_IOCTL_DEF_DRV(MTK_GEM_MAP_OFFSET, + mediatek_gem_map_offset_ioctl, + DRM_UNLOCKED | DRM_AUTH), +}; + +static const struct file_operations mediatek_drm_fops = { + .owner = THIS_MODULE, + .open = drm_open, + .release = drm_release, + .unlocked_ioctl = drm_ioctl, + .mmap = mtk_drm_gem_mmap, + .poll = drm_poll, + .read = drm_read, +#ifdef CONFIG_COMPAT + .compat_ioctl = drm_compat_ioctl, +#endif +}; + +static struct drm_driver mediatek_drm_driver = { + .driver_features = DRIVER_MODESET | DRIVER_GEM, + .load = mtk_drm_load, + .unload = mtk_drm_unload, + .open = mtk_drm_open, + .preclose = mediatek_drm_preclose, + .lastclose = mediatek_drm_lastclose, + .set_busid = drm_platform_set_busid, + + .get_vblank_counter = drm_vblank_count, + .enable_vblank = mtk_drm_crtc_enable_vblank, + .disable_vblank = mtk_drm_crtc_disable_vblank, + + .gem_free_object = mtk_drm_gem_free_object, + .gem_vm_ops = &mediatek_drm_gem_vm_ops, + .dumb_create = mtk_drm_gem_dumb_create, + .dumb_map_offset = mtk_drm_gem_dumb_map_offset, + .dumb_destroy = drm_gem_dumb_destroy, + + .num_ioctls = 0, + .fops = &mediatek_drm_fops, + + .set_busid = drm_platform_set_busid, + + .name = DRIVER_NAME, + .desc = DRIVER_DESC, + .date = DRIVER_DATE, + .major = DRIVER_MAJOR, + .minor = DRIVER_MINOR, +}; + +static int compare_of(struct device *dev, void *data) +{ + return dev->of_node == data; +} + +static int mtk_drm_add_components(struct device *master, struct master *m) +{ + struct device_node *np = master->of_node; + unsigned i; + int ret; + + for (i = 0; ; i++) { + struct device_node *node; + + node = of_parse_phandle(np, "connectors", i); + if (!node) + break; + + ret = component_master_add_child(m, compare_of, node); + of_node_put(node); + if (ret) { + dev_err(master, "component_master_add_child %s fail.\n", + node->full_name); + return ret; + } + } + + for (i = 0; ; i++) { + struct device_node *node; + + node = of_parse_phandle(np, "crtcs", i); + if (!node) + break; + + ret = component_master_add_child(m, compare_of, node); + of_node_put(node); + if (ret) { + dev_err(master, "component_master_add_child %s fail.\n", + node->full_name); + return ret; + } + } + + return 0; +} + +static int mtk_drm_bind(struct device *dev) +{ + return drm_platform_init(&mediatek_drm_driver, to_platform_device(dev)); +} + +static void mtk_drm_unbind(struct device *dev) +{ + drm_put_dev(platform_get_drvdata(to_platform_device(dev))); +} + +static const struct component_master_ops mtk_drm_ops = { + .add_components = mtk_drm_add_components, + .bind = mtk_drm_bind, + .unbind = mtk_drm_unbind, +}; + +static int mtk_drm_probe(struct platform_device *pdev) +{ + component_master_add(&pdev->dev, &mtk_drm_ops); + + return 0; +} + +static int mtk_drm_remove(struct platform_device *pdev) +{ + drm_put_dev(platform_get_drvdata(pdev)); + + return 0; +} + +static const struct of_device_id mediatek_drm_of_ids[] = { + { .compatible = "mediatek,mt8173-drm", }, + { } +}; + +static struct platform_driver mediatek_drm_platform_driver = { + .probe = mtk_drm_probe, + .remove = mtk_drm_remove, + .driver = { + .owner = THIS_MODULE, + .name = "mediatek-drm", + .of_match_table = mediatek_drm_of_ids, + /*.pm = &mtk_pm_ops, */ + }, + /* .id_table = mtk_drm_platform_ids, */ +}; + +static int mediatek_drm_init(void) +{ + int err; + + err = platform_driver_register(&mediatek_ddp_driver); + if (err < 0) { + DRM_DEBUG_DRIVER("register ddp driver fail.\n"); + return err; + } + + err = platform_driver_register(&mtk_dsi_driver); + if (err < 0) { + DRM_DEBUG_DRIVER("register dsi driver fail.\n"); + return err; + } + + err = platform_driver_register(&mediatek_crtc_main_driver); + if (err < 0) { + DRM_DEBUG_DRIVER("register crtc_main driver fail.\n"); + return err; + } + + err = platform_driver_register(&mediatek_drm_platform_driver); + if (err < 0) + return err; + + return 0; +} + +static void mediatek_drm_exit(void) +{ + platform_driver_unregister(&mediatek_drm_platform_driver); + platform_driver_unregister(&mtk_dsi_driver); +} + +late_initcall(mediatek_drm_init); +module_exit(mediatek_drm_exit); + +MODULE_AUTHOR("YT SHEN yt.shen@mediatek.com"); +MODULE_DESCRIPTION("Mediatek SoC DRM driver"); +MODULE_LICENSE("GPL"); + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_drv.h b/drivers/gpu/drm/mediatek/mediatek_drm_drv.h new file mode 100644 index 0000000..10ee4c4 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_drv.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + +#ifndef _MEDIATEK_DRM_DRV_H_ +#define _MEDIATEK_DRM_DRV_H_ + +#define MAX_CRTC 2 +#define MAX_PLANE 4 + +extern struct platform_driver mediatek_ddp_driver; +extern struct platform_driver mtk_dsi_driver; +extern struct platform_driver mediatek_crtc_main_driver; + +struct mtk_drm_private { + struct drm_fb_helper *fb_helper; + + /* + * created crtc object would be contained at this array and + * this array is used to be aware of which crtc did it request vblank. + */ + struct drm_crtc *crtc[MAX_CRTC]; + unsigned int pipe; +}; + + +#endif + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_dsi.c b/drivers/gpu/drm/mediatek/mediatek_drm_dsi.c new file mode 100644 index 0000000..199ff9d --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_dsi.c @@ -0,0 +1,1333 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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 <drm/drm_gem.h> +#include <drm/drm_crtc_helper.h> + +#include <linux/clk.h> +#include <linux/debugfs.h> +#include <linux/module.h> +#include <linux/of.h> +#include <linux/platform_device.h> +#include <linux/reset.h> + +#include <linux/of_gpio.h> +#include <linux/gpio.h> + +#include <linux/gpio/consumer.h> +#include <linux/module.h> +#include <linux/of_platform.h> +#include <linux/of_graph.h> +#include <linux/component.h> + +#include <linux/regulator/consumer.h> + +#include <drm/drm_mipi_dsi.h> +#include <drm/drm_panel.h> + +#include <video/mipi_display.h> +#include <video/videomode.h> + +#include "mediatek_drm_drv.h" +#include "mediatek_drm_crtc.h" + +#include "mediatek_drm_ddp.h" + +#include "mediatek_drm_gem.h" +#include "mediatek_drm_dsi.h" + + +#define DSI_VIDEO_FIFO_DEPTH (1920 / 4) +#define DSI_HOST_FIFO_DEPTH 64 + + +#define DSI_START 0x00 + +#define DSI_CON_CTRL 0x10 + #define DSI_RESET (1) + +#define DSI_MODE_CTRL 0x14 + #define MODE 2 + #define CMD_MODE 0 + #define SYNC_PULSE_MODE 1 + #define SYNC_EVENT_MODE 2 + #define BURST_MODE 3 + #define FRM_MODE (1<<16) + #define MIX_MODE (1<<17) + +#define DSI_TXRX_CTRL 0x18 + #define VC_NUM (2<<0) + #define LANE_NUM (0xf<<2) + #define DIS_EOT (1<<6) + #define NULL_EN (1<<7) + #define TE_FREERUN (1<<8) + #define EXT_TE_EN (1<<9) + #define EXT_TE_EDGE (1<<10) + #define MAX_RTN_SIZE (0xf<<12) + #define HSTX_CKLP_EN (1<<16) + +#define DSI_PSCTRL 0x1c + #define DSI_PS_WC 0x3fff + #define DSI_PS_SEL (2<<16) + #define PACKED_PS_16BIT_RGB565 (0<<16) + #define LOOSELY_PS_18BIT_RGB666 (1<<16) + #define PACKED_PS_18BIT_RGB666 (2<<16) + #define PACKED_PS_24BIT_RGB888 (3<<16) + +#define DSI_VSA_NL 0x20 +#define DSI_VBP_NL 0x24 +#define DSI_VFP_NL 0x28 + +#define DSI_VACT_NL 0x2C + +#define DSI_HSA_WC 0x50 +#define DSI_HBP_WC 0x54 +#define DSI_HFP_WC 0x58 + +#define DSI_HSTX_CKL_WC 0x64 + +#define DSI_PHY_LCCON 0x104 + #define LC_HS_TX_EN (1) + #define LC_ULPM_EN (1<<1) + #define LC_WAKEUP_EN (1<<2) + +#define DSI_PHY_LD0CON 0x108 + #define LD0_HS_TX_EN (1) + #define LD0_ULPM_EN (1<<1) + #define LD0_WAKEUP_EN (1<<2) + +#define DSI_PHY_TIMECON0 0x0110 + #define LPX (0xff<<0) + #define HS_PRPR (0xff<<8) + #define HS_ZERO (0xff<<16) + #define HS_TRAIL (0xff<<24) + +#define DSI_PHY_TIMECON1 0x0114 + #define TA_GO (0xff<<0) + #define TA_SURE (0xff<<8) + #define TA_GET (0xff<<16) + #define DA_HS_EXIT (0xff<<24) + +#define DSI_PHY_TIMECON2 0x0118 + #define CONT_DET (0xff<<0) + #define CLK_ZERO (0xff<<16) + #define CLK_TRAIL (0xff<<24) + +#define DSI_PHY_TIMECON3 0x011c + #define CLK_HS_PRPR (0xff<<0) + #define CLK_HS_POST (0xff<<8) + #define CLK_HS_EXIT (0xff<<16) + +#define MIPITX_DSI0_CON 0x00 + #define RG_DSI0_LDOCORE_EN (1) + #define RG_DSI0_CKG_LDOOUT_EN (1<<1) + #define RG_DSI0_BCLK_SEL (3<<2) + #define RG_DSI0_LD_IDX_SEL (7<<4) + #define RG_DSI0_PHYCLK_SEL (2<<8) + #define RG_DSI0_DSICLK_FREQ_SEL (1<<10) + #define RG_DSI0_LPTX_CLMP_EN (1<<11) + +#define MIPITX_DSI0_CLOCK_LANE 0x04 + #define RG_DSI0_LNTC_LDOOUT_EN (1) + #define RG_DSI0_LNTC_CKLANE_EN (1<<1) + #define RG_DSI0_LNTC_LPTX_IPLUS1 (1<<2) + #define RG_DSI0_LNTC_LPTX_IPLUS2 (1<<3) + #define RG_DSI0_LNTC_LPTX_IMINUS (1<<4) + #define RG_DSI0_LNTC_LPCD_IPLUS (1<<5) + #define RG_DSI0_LNTC_LPCD_IMLUS (1<<6) + #define RG_DSI0_LNTC_RT_CODE (0xf<<8) + +#define MIPITX_DSI0_DATA_LANE0 0x08 + #define RG_DSI0_LNT0_LDOOUT_EN (1) + #define RG_DSI0_LNT0_CKLANE_EN (1<<1) + #define RG_DSI0_LNT0_LPTX_IPLUS1 (1<<2) + #define RG_DSI0_LNT0_LPTX_IPLUS2 (1<<3) + #define RG_DSI0_LNT0_LPTX_IMINUS (1<<4) + #define RG_DSI0_LNT0_LPCD_IPLUS (1<<5) + #define RG_DSI0_LNT0_LPCD_IMINUS (1<<6) + #define RG_DSI0_LNT0_RT_CODE (0xf<<8) + +#define MIPITX_DSI0_DATA_LANE1 0x0c + #define RG_DSI0_LNT1_LDOOUT_EN (1) + #define RG_DSI0_LNT1_CKLANE_EN (1<<1) + #define RG_DSI0_LNT1_LPTX_IPLUS1 (1<<2) + #define RG_DSI0_LNT1_LPTX_IPLUS2 (1<<3) + #define RG_DSI0_LNT1_LPTX_IMINUS (1<<4) + #define RG_DSI0_LNT1_LPCD_IPLUS (1<<5) + #define RG_DSI0_LNT1_LPCD_IMINUS (1<<6) + #define RG_DSI0_LNT1_RT_CODE (0xf<<8) + +#define MIPITX_DSI0_DATA_LANE2 0x10 + #define RG_DSI0_LNT2_LDOOUT_EN (1) + #define RG_DSI0_LNT2_CKLANE_EN (1<<1) + #define RG_DSI0_LNT2_LPTX_IPLUS1 (1<<2) + #define RG_DSI0_LNT2_LPTX_IPLUS2 (1<<3) + #define RG_DSI0_LNT2_LPTX_IMINUS (1<<4) + #define RG_DSI0_LNT2_LPCD_IPLUS (1<<5) + #define RG_DSI0_LNT2_LPCD_IMINUS (1<<6) + #define RG_DSI0_LNT2_RT_CODE (0xf<<8) + +#define MIPITX_DSI0_DATA_LANE3 0x14 + #define RG_DSI0_LNT3_LDOOUT_EN (1) + #define RG_DSI0_LNT3_CKLANE_EN (1<<1) + #define RG_DSI0_LNT3_LPTX_IPLUS1 (1<<2) + #define RG_DSI0_LNT3_LPTX_IPLUS2 (1<<3) + #define RG_DSI0_LNT3_LPTX_IMINUS (1<<4) + #define RG_DSI0_LNT3_LPCD_IPLUS (1<<5) + #define RG_DSI0_LNT3_LPCD_IMINUS (1<<6) + #define RG_DSI0_LNT3_RT_CODE (0xf<<8) + +#define MIPITX_DSI_TOP_CON 0x40 + #define RG_DSI_LNT_INTR_EN (1) + #define RG_DSI_LNT_HS_BIAS_EN (1<<1) + #define RG_DSI_LNT_IMP_CAL_EN (1<<2) + #define RG_DSI_LNT_TESTMODE_EN (1<<3) + #define RG_DSI_LNT_IMP_CAL_CODE (0xf<<4) + #define RG_DSI_LNT_AIO_SEL (7<<8) + #define RG_DSI_PAD_TIE_LOW_EN (1<<11) + #define RG_DSI_DEBUG_INPUT_EN (1<<12) + #define RG_DSI_PRESERVE (7<<13) + +#define MIPITX_DSI_BG_CON 0x44 + #define RG_DSI_BG_CORE_EN 1 + #define RG_DSI_BG_CKEN (1<<1) + #define RG_DSI_BG_DIV (0x3<<2) + #define RG_DSI_BG_FAST_CHARGE (1<<4) + #define RG_DSI_V12_SEL (7<<5) + #define RG_DSI_V10_SEL (7<<8) + #define RG_DSI_V072_SEL (7<<11) + #define RG_DSI_V04_SEL (7<<14) + #define RG_DSI_V032_SEL (7<<17) + #define RG_DSI_V02_SEL (7<<20) + #define rsv_23 (1<<) + #define RG_DSI_BG_R1_TRIM (0xf<<24) + #define RG_DSI_BG_R2_TRIM (0xf<<28) + +#define MIPITX_DSI_PLL_CON0 0x50 + #define RG_DSI0_MPPLL_PLL_EN (1<<0) + #define RG_DSI0_MPPLL_PREDIV (3<<1) + #define RG_DSI0_MPPLL_TXDIV0 (3<<3) + #define RG_DSI0_MPPLL_TXDIV1 (3<<5) + #define RG_DSI0_MPPLL_POSDIV (7<<7) + #define RG_DSI0_MPPLL_MONVC_EN (1<<10) + #define RG_DSI0_MPPLL_MONREF_EN (1<<11) + #define RG_DSI0_MPPLL_VOD_EN (1<<12) + +#define MIPITX_DSI_PLL_CON1 0x54 + #define RG_DSI0_MPPLL_SDM_FRA_EN (1) + #define RG_DSI0_MPPLL_SDM_SSC_PH_INIT (1<<1) + #define RG_DSI0_MPPLL_SDM_SSC_EN (1<<2) + #define RG_DSI0_MPPLL_SDM_SSC_PRD (0xffff<<16) + +#define MIPITX_DSI_PLL_CON2 0x58 + +#define MIPITX_DSI_PLL_PWR 0x68 + #define RG_DSI_MPPLL_SDM_PWR_ON (1<<0) + #define RG_DSI_MPPLL_SDM_ISO_EN (1<<1) + #define RG_DSI_MPPLL_SDM_PWR_ACK (1<<8) + +#define MIPITX_DSI_SW_CTRL 0x80 + #define SW_CTRL_EN (1<<0) + +#define MIPITX_DSI_SW_CTRL_CON0 0x84 + #define SW_LNTC_LPTX_PRE_OE (1<<0) + #define SW_LNTC_LPTX_OE (1<<1) + #define SW_LNTC_LPTX_P (1<<2) + #define SW_LNTC_LPTX_N (1<<3) + #define SW_LNTC_HSTX_PRE_OE (1<<4) + #define SW_LNTC_HSTX_OE (1<<5) + #define SW_LNTC_HSTX_ZEROCLK (1<<6) + #define SW_LNT0_LPTX_PRE_OE (1<<7) + #define SW_LNT0_LPTX_OE (1<<8) + #define SW_LNT0_LPTX_P (1<<9) + #define SW_LNT0_LPTX_N (1<<10) + #define SW_LNT0_HSTX_PRE_OE (1<<11) + #define SW_LNT0_HSTX_OE (1<<12) + #define SW_LNT0_LPRX_EN (1<<13) + #define SW_LNT1_LPTX_PRE_OE (1<<14) + #define SW_LNT1_LPTX_OE (1<<15) + #define SW_LNT1_LPTX_P (1<<16) + #define SW_LNT1_LPTX_N (1<<17) + #define SW_LNT1_HSTX_PRE_OE (1<<18) + #define SW_LNT1_HSTX_OE (1<<19) + #define SW_LNT2_LPTX_PRE_OE (1<<20) + #define SW_LNT2_LPTX_OE (1<<21) + #define SW_LNT2_LPTX_P (1<<22) + #define SW_LNT2_LPTX_N (1<<23) + #define SW_LNT2_HSTX_PRE_OE (1<<24) + #define SW_LNT2_HSTX_OE (1<<25) + +#define NS_TO_CYCLE(n, c) ((n) / c + (((n) % c) ? 1 : 0)) + + +static inline unsigned long mtk_dsi_readl(struct mtk_dsi *dsi, + unsigned long reg) +{ + return readl(dsi->dsi_reg_base + (reg << 2)); +} + +static inline void mtk_dsi_writel(struct mtk_dsi *dsi, unsigned long value, + unsigned long reg) +{ + writel(value, dsi->dsi_reg_base + (reg << 2)); +} + +static int mtk_dsi_of_read_u32(const struct device_node *np, + const char *propname, u32 *out_value) +{ + int ret = of_property_read_u32(np, propname, out_value); + + if (ret < 0) + DRM_ERROR("%s: failed to get '%s' property\n", np->full_name, + propname); + + return ret; +} + +static void dsi_phy_clk_switch_off(struct mtk_dsi *dsi) +{ + u32 tmp_reg; + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_SW_CTRL_CON0); + + tmp_reg = tmp_reg | (SW_LNTC_LPTX_PRE_OE | SW_LNTC_LPTX_OE | + SW_LNTC_HSTX_PRE_OE | SW_LNTC_HSTX_OE | + SW_LNT0_LPTX_PRE_OE | SW_LNT0_LPTX_OE | + SW_LNT0_HSTX_PRE_OE | SW_LNT0_HSTX_OE | + SW_LNT1_LPTX_PRE_OE | SW_LNT1_LPTX_OE | + SW_LNT1_HSTX_PRE_OE | SW_LNT1_HSTX_OE | + SW_LNT2_LPTX_PRE_OE | SW_LNT2_LPTX_OE | + SW_LNT2_HSTX_PRE_OE | SW_LNT2_HSTX_OE); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI_SW_CTRL_CON0); + + + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_SW_CTRL); + tmp_reg = (tmp_reg | SW_CTRL_EN); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI_SW_CTRL); + + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + tmp_reg = (tmp_reg & (~RG_DSI0_MPPLL_PLL_EN)); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + + + udelay(100); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_TOP_CON); + tmp_reg = (tmp_reg & (~(RG_DSI_LNT_HS_BIAS_EN | + RG_DSI_LNT_IMP_CAL_EN | + RG_DSI_LNT_TESTMODE_EN))); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI_TOP_CON); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_CLOCK_LANE); + tmp_reg = tmp_reg & (~RG_DSI0_LNTC_LDOOUT_EN); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_CLOCK_LANE); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE0); + tmp_reg = tmp_reg & (~RG_DSI0_LNT0_LDOOUT_EN); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE0); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE1); + tmp_reg = tmp_reg & (~RG_DSI0_LNT1_LDOOUT_EN); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE1); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE2); + tmp_reg = tmp_reg & (~RG_DSI0_LNT2_LDOOUT_EN); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE2); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE3); + tmp_reg = tmp_reg & (~RG_DSI0_LNT3_LDOOUT_EN); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE3); + + + udelay(100); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_CON); + tmp_reg = tmp_reg & (~(RG_DSI0_CKG_LDOOUT_EN | + RG_DSI0_LDOCORE_EN)); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_CON); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_BG_CON); + tmp_reg = tmp_reg & (~(RG_DSI_BG_CKEN | RG_DSI_BG_CORE_EN)); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI_BG_CON); + + + udelay(100); + + tmp_reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + tmp_reg = (tmp_reg & (~RG_DSI0_MPPLL_PLL_EN)); + writel(tmp_reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); +} + +static void dsi_phy_clk_setting(struct mtk_dsi *dsi) +{ + unsigned int data_Rate = dsi->pll_clk_rate * 2; + unsigned int txdiv = 0; + unsigned int txdiv0 = 0; + unsigned int txdiv1 = 0; + unsigned int pcw = 0; + u32 reg; + u32 temp; + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_BG_CON); + reg = (reg & (~RG_DSI_V032_SEL)) | (4<<17); + reg = (reg & (~RG_DSI_V04_SEL)) | (4<<14); + reg = (reg & (~RG_DSI_V072_SEL)) | (4<<11); + reg = (reg & (~RG_DSI_V10_SEL)) | (4<<8); + reg = (reg & (~RG_DSI_V12_SEL)) | (4<<5); + reg = (reg & (~RG_DSI_BG_CKEN)) | (1<<1); + reg = (reg & (~RG_DSI_BG_CORE_EN)) | (1); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_BG_CON); + + udelay(1000); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_TOP_CON); + reg = (reg & (~RG_DSI_LNT_IMP_CAL_CODE)) | (8<<4); + reg = (reg & (~RG_DSI_LNT_HS_BIAS_EN)) | (1<<1); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_TOP_CON); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_CON); + reg = (reg & (~RG_DSI0_CKG_LDOOUT_EN)) | (1<<1); + reg = (reg & (~RG_DSI0_LDOCORE_EN)) | (1); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_CON); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_PWR); + reg = (reg & (~RG_DSI_MPPLL_SDM_PWR_ON)) | (1<<0); + reg = (reg & (~RG_DSI_MPPLL_SDM_ISO_EN)); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_PWR); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + reg = (reg & (~RG_DSI0_MPPLL_PLL_EN)); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + + udelay(1000); + + if (data_Rate > 1250) { + txdiv = 1; + txdiv0 = 0; + txdiv1 = 0; + } else if (data_Rate >= 500) { + txdiv = 1; + txdiv0 = 0; + txdiv1 = 0; + } else if (data_Rate >= 250) { + txdiv = 2; + txdiv0 = 1; + txdiv1 = 0; + } else if (data_Rate >= 125) { + txdiv = 4; + txdiv0 = 2; + txdiv1 = 0; + } else if (data_Rate > 62) { + txdiv = 8; + txdiv0 = 2; + txdiv1 = 1; + } else if (data_Rate >= 50) { + txdiv = 16; + txdiv0 = 2; + txdiv1 = 2; + } else { + } + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + + switch (txdiv) { + case 1: + reg = (reg & (~RG_DSI0_MPPLL_TXDIV0)) | (0<<3); + reg = (reg & (~RG_DSI0_MPPLL_TXDIV1)) | (0<<5); + + break; + case 2: + reg = (reg & (~RG_DSI0_MPPLL_TXDIV0)) | (1<<3); + reg = (reg & (~RG_DSI0_MPPLL_TXDIV1)) | (0<<5); + break; + case 4: + reg = (reg & (~RG_DSI0_MPPLL_TXDIV0)) | (2<<3); + reg = (reg & (~RG_DSI0_MPPLL_TXDIV1)) | (0<<5); + break; + case 8: + reg = (reg & (~RG_DSI0_MPPLL_TXDIV0)) | (2<<3); + reg = (reg & (~RG_DSI0_MPPLL_TXDIV1)) | (1<<5); + break; + case 16: + reg = (reg & (~RG_DSI0_MPPLL_TXDIV0)) | (2<<3); + reg = (reg & (~RG_DSI0_MPPLL_TXDIV1)) | (2<<5); + break; + + default: + break; + } + reg = (reg & (~RG_DSI0_MPPLL_PREDIV)); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + + pcw = data_Rate * txdiv / 13; + temp = data_Rate * txdiv % 13; + reg = ((pcw & 0x7f)<<24) + (((256 * temp / 13) & 0xff)<<16) + + (((256 * (256 * temp % 13)/13) & 0xff)<<8) + + ((256 * (256 * (256 * temp % 13) % 13) / 13) & 0xff); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON2); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON1); + reg = (reg & (~RG_DSI0_MPPLL_SDM_FRA_EN)) | (1<<0); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON1); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_CLOCK_LANE); + reg = (reg & (~RG_DSI0_LNTC_LDOOUT_EN)) | (1<<0); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_CLOCK_LANE); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE0); + reg = (reg & (~RG_DSI0_LNT0_LDOOUT_EN)) | (1<<0); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE0); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE1); + reg = (reg & (~RG_DSI0_LNT1_LDOOUT_EN)) | (1<<0); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE1); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE2); + reg = (reg & (~RG_DSI0_LNT2_LDOOUT_EN)) | (1<<0); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE2); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE3); + reg = (reg & (~RG_DSI0_LNT3_LDOOUT_EN)) | (1<<0); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI0_DATA_LANE3); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + reg = (reg & (~RG_DSI0_MPPLL_PLL_EN)) | (1<<0); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON0); + + udelay(1000); + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON1); + reg = (reg & (~RG_DSI0_MPPLL_SDM_SSC_EN)); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_PLL_CON1); + + reg = readl(dsi->dsi_tx_reg_base + MIPITX_DSI_TOP_CON); + reg = (reg & (~RG_DSI_PAD_TIE_LOW_EN)); + writel(reg, dsi->dsi_tx_reg_base + MIPITX_DSI_TOP_CON); +} + +static void dsi_phy_timconfig(struct mtk_dsi *dsi) +{ + u32 timcon0 = 0; + u32 timcon1 = 0; + u32 timcon2 = 0; + u32 timcon3 = 0; + unsigned int lane_no = dsi->lanes; + unsigned int cycle_time; + unsigned int ui; + unsigned int hs_trail_m, hs_trail_n; + + ui = 1000/(250 * 2) + 0x01; + cycle_time = 8000/(250 * 2) + 0x01; + + hs_trail_m = lane_no; + hs_trail_n = NS_TO_CYCLE(((lane_no * 4 * ui) + 60), cycle_time); + + timcon0 = (timcon0 & (~HS_TRAIL)) | (8<<24); + timcon0 = (timcon0 & (~HS_PRPR)) | 0x6<<8; + + if ((timcon0 & HS_PRPR) == 0) + timcon0 = (timcon0 & (~HS_PRPR)) | 1<<8; + + timcon0 = (timcon0 & (~HS_ZERO)) | 0xA<<16; + timcon0 = (timcon0 & (~LPX)) | 5; + + if ((timcon0 & LPX) == 0) + timcon0 = (timcon0 & (~LPX)) | 1; + + timcon1 = (timcon1 & (~TA_GET)) | (5 * (timcon0 & LPX)<<16); + timcon1 = (timcon1 & (~TA_SURE)) | ((3 * (timcon0 & LPX) / 2) << 8); + timcon1 = (timcon1 & (~TA_GO)) | (4 * (timcon0 & LPX)); + timcon1 = (timcon1 & (~DA_HS_EXIT)) | (7<<24); + timcon2 = (timcon2 & (~CLK_TRAIL)) | ((NS_TO_CYCLE(0x64, cycle_time) + + 0x0a)<<24); + + if (((timcon2 & CLK_TRAIL)>>24) < 2) + timcon2 = (timcon2 & (~CLK_TRAIL)) | (2<<24); + + timcon2 = (timcon2 & (~CONT_DET)); + timcon3 = (timcon3 & (~CLK_HS_PRPR)) | NS_TO_CYCLE(0x40, cycle_time); + if ((timcon3 & CLK_HS_PRPR) == 0) + timcon3 = (timcon3 & (~CLK_HS_PRPR)) | 1; + + timcon2 = (timcon2 & (~CLK_ZERO)) | + (NS_TO_CYCLE(0x190 - (timcon3 & CLK_HS_PRPR) * cycle_time, + cycle_time)<<16); + + timcon3 = (timcon3 & (~CLK_HS_EXIT)) | ((2 * (timcon0 & LPX))<<16); + timcon3 = (timcon3 & (~CLK_HS_POST)) | (NS_TO_CYCLE((80 + 52 * ui), + cycle_time)<<8); + + writel(timcon0, dsi->dsi_reg_base + DSI_PHY_TIMECON0); + writel(timcon1, dsi->dsi_reg_base + DSI_PHY_TIMECON1); + writel(timcon2, dsi->dsi_reg_base + DSI_PHY_TIMECON2); + writel(timcon3, dsi->dsi_reg_base + DSI_PHY_TIMECON3); +} + +static void mtk_dsi_reset(struct mtk_dsi *dsi) +{ + writel(3, dsi->dsi_reg_base + DSI_CON_CTRL); + writel(2, dsi->dsi_reg_base + DSI_CON_CTRL); +} + +static int mtk_dsi_poweron(struct mtk_dsi *dsi) +{ + int ret; + struct drm_device *dev = dsi->drm_dev; + + dsi_phy_clk_setting(dsi); + + ret = clk_prepare_enable(dsi->dsi0_engine_clk_cg); + if (ret < 0) { + dev_err(dev->dev, "can't enable dsi0_engine_clk_cg %d\n", ret); + goto err_dsi0_engine_clk_cg; + } + + ret = clk_prepare_enable(dsi->dsi0_digital_clk_cg); + if (ret < 0) { + dev_err(dev->dev, "can't enable dsi0_digital_clk_cg %d\n", ret); + goto err_dsi0_digital_clk_cg; + } + + mtk_dsi_reset((dsi)); + dsi_phy_timconfig(dsi); + + return 0; + +err_dsi0_digital_clk_cg: + clk_disable_unprepare(dsi->dsi0_engine_clk_cg); + +err_dsi0_engine_clk_cg: + + return ret; +} + +static void dsi_clk_ulp_mode_enter(struct mtk_dsi *dsi) +{ + u32 tmp_reg1; + + tmp_reg1 = readl(dsi->dsi_reg_base + DSI_PHY_LCCON); + tmp_reg1 = tmp_reg1 & (~LC_HS_TX_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LCCON); + udelay(100); + tmp_reg1 = tmp_reg1 & (~LC_ULPM_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LCCON); + udelay(100); +} + +static void dsi_clk_ulp_mode_leave(struct mtk_dsi *dsi) +{ + u32 tmp_reg1; + + tmp_reg1 = readl(dsi->dsi_reg_base + DSI_PHY_LCCON); + tmp_reg1 = tmp_reg1 & (~LC_ULPM_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LCCON); + udelay(100); + tmp_reg1 = tmp_reg1 | LC_WAKEUP_EN; + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LCCON); + udelay(100); + tmp_reg1 = tmp_reg1 & (~LC_WAKEUP_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LCCON); + udelay(100); +} + +static void dsi_lane0_ulp_mode(struct mtk_dsi *dsi, bool enter) +{ + u32 tmp_reg1; + + tmp_reg1 = readl(dsi->dsi_reg_base + DSI_PHY_LD0CON); + + if (enter) { + tmp_reg1 = tmp_reg1 & (~LD0_HS_TX_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LD0CON); + udelay(100); + tmp_reg1 = tmp_reg1 & (~LD0_ULPM_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LD0CON); + udelay(100); + } else { + tmp_reg1 = tmp_reg1 & (~LD0_ULPM_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LD0CON); + udelay(100); + tmp_reg1 = tmp_reg1 | LD0_WAKEUP_EN; + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LD0CON); + udelay(100); + tmp_reg1 = tmp_reg1 & (~LD0_WAKEUP_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LD0CON); + udelay(100); + } +} + +static bool dsi_clk_hs_state(struct mtk_dsi *dsi) +{ + u32 tmp_reg1; + + tmp_reg1 = readl(dsi->dsi_reg_base + DSI_PHY_LCCON); + + return ((tmp_reg1 & LC_HS_TX_EN) == 1) ? true : false; +} + +static void dsi_clk_hs_mode(struct mtk_dsi *dsi, bool enter) +{ + u32 tmp_reg1; + + tmp_reg1 = readl(dsi->dsi_reg_base + DSI_PHY_LCCON); + + if (enter && !dsi_clk_hs_state(dsi)) { + tmp_reg1 = tmp_reg1 | LC_HS_TX_EN; + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LCCON); + } else if (!enter && dsi_clk_hs_state(dsi)) { + tmp_reg1 = tmp_reg1 & (~LC_HS_TX_EN); + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PHY_LCCON); + } +} + +static void dsi_set_mode(struct mtk_dsi *dsi) +{ + u32 tmp_reg1; + + tmp_reg1 = 0; + + if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO) { + tmp_reg1 = SYNC_PULSE_MODE; + + if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_BURST) + tmp_reg1 = BURST_MODE; + + if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE) + tmp_reg1 = SYNC_PULSE_MODE; + } + + writel(tmp_reg1, dsi->dsi_reg_base + DSI_MODE_CTRL); +} + +static void dsi_ps_control_vact(struct mtk_dsi *dsi) +{ + struct videomode *vm = &dsi->vm; + u32 dsiTmpBufBpp, ps_wc; + u32 tmp_reg; + u32 tmp_hstx_cklp_wc; + + tmp_reg = 0; + + if (dsi->format == MIPI_DSI_FMT_RGB565) + dsiTmpBufBpp = 2; + else + dsiTmpBufBpp = 3; + + ps_wc = vm->vactive * dsiTmpBufBpp; + + tmp_reg = ps_wc; + + switch (dsi->format) { + case MIPI_DSI_FMT_RGB888: + tmp_reg |= PACKED_PS_24BIT_RGB888; + break; + case MIPI_DSI_FMT_RGB666: + tmp_reg |= PACKED_PS_18BIT_RGB666; + break; + case MIPI_DSI_FMT_RGB666_PACKED: + tmp_reg |= LOOSELY_PS_18BIT_RGB666; + break; + case MIPI_DSI_FMT_RGB565: + tmp_reg |= PACKED_PS_16BIT_RGB565; + break; + } + + tmp_hstx_cklp_wc = ps_wc; + + writel(vm->vactive, dsi->dsi_reg_base + DSI_VACT_NL); + writel(tmp_reg, dsi->dsi_reg_base + DSI_PSCTRL); + writel(tmp_hstx_cklp_wc, dsi->dsi_reg_base + DSI_HSTX_CKL_WC); +} + +static void dsi_rxtx_control(struct mtk_dsi *dsi) +{ + u32 tmp_reg = 0; + + switch (dsi->lanes) { + case 1: + tmp_reg = 1<<2; + break; + case 2: + tmp_reg = 3<<2; + break; + case 3: + tmp_reg = 7<<2; + break; + case 4: + tmp_reg = 0xF<<2; + break; + default: + tmp_reg = 0xF<<2; + break; + } + + writel(tmp_reg, dsi->dsi_reg_base + DSI_TXRX_CTRL); +} + +void dsi_ps_control(struct mtk_dsi *dsi) +{ + unsigned int dsi_tmp_buf_bpp; + u32 tmp_reg1 = 0; + + switch (dsi->format) { + case MIPI_DSI_FMT_RGB888: + tmp_reg1 = PACKED_PS_24BIT_RGB888; + dsi_tmp_buf_bpp = 3; + break; + case MIPI_DSI_FMT_RGB666: + tmp_reg1 = LOOSELY_PS_18BIT_RGB666; + dsi_tmp_buf_bpp = 3; + break; + case MIPI_DSI_FMT_RGB666_PACKED: + tmp_reg1 = PACKED_PS_18BIT_RGB666; + dsi_tmp_buf_bpp = 3; + break; + case MIPI_DSI_FMT_RGB565: + tmp_reg1 = PACKED_PS_16BIT_RGB565; + dsi_tmp_buf_bpp = 2; + break; + default: + tmp_reg1 = PACKED_PS_24BIT_RGB888; + dsi_tmp_buf_bpp = 3; + break; + } + + tmp_reg1 = tmp_reg1 + ((dsi->vm.hactive * dsi_tmp_buf_bpp) & DSI_PS_WC); + + writel(tmp_reg1, dsi->dsi_reg_base + DSI_PSCTRL); +} + +static void dsi_config_vdo_timing(struct mtk_dsi *dsi) +{ + unsigned int horizontal_sync_active_byte; + unsigned int horizontal_backporch_byte; + unsigned int horizontal_frontporch_byte; + unsigned int dsi_tmp_buf_bpp; + + struct videomode *vm = &dsi->vm; + + if (dsi->format == MIPI_DSI_FMT_RGB565) + dsi_tmp_buf_bpp = 2; + else + dsi_tmp_buf_bpp = 3; + + writel(vm->vsync_len, dsi->dsi_reg_base + DSI_VSA_NL); + writel(vm->vback_porch, dsi->dsi_reg_base + DSI_VBP_NL); + writel(vm->vfront_porch, dsi->dsi_reg_base + DSI_VFP_NL); + writel(vm->vactive, dsi->dsi_reg_base + DSI_VACT_NL); + + horizontal_sync_active_byte = (vm->hsync_len * dsi_tmp_buf_bpp - 10); + + if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE) + horizontal_backporch_byte = + (vm->hback_porch * dsi_tmp_buf_bpp - 10); + else + horizontal_backporch_byte = ((vm->hback_porch + vm->hsync_len) * + dsi_tmp_buf_bpp - 10); + + horizontal_frontporch_byte = (vm->vfront_porch * dsi_tmp_buf_bpp - 12); + + writel(vm->hsync_len, dsi->dsi_reg_base + DSI_HSA_WC); + writel(vm->hback_porch, dsi->dsi_reg_base + DSI_HBP_WC); + writel(vm->hfront_porch, dsi->dsi_reg_base + DSI_HFP_WC); + + dsi_ps_control(dsi); +} + +static void mtk_dsi_start(struct mtk_dsi *dsi) +{ + writel(0, dsi->dsi_reg_base + DSI_START); + writel(1, dsi->dsi_reg_base + DSI_START); +} + +static void mtk_dsi_poweroff(struct mtk_dsi *dsi) +{ + clk_disable_unprepare(dsi->dsi0_engine_clk_cg); + clk_disable_unprepare(dsi->dsi0_digital_clk_cg); + + usleep_range(10000, 20000); + + dsi_phy_clk_switch_off(dsi); +} + +static int mtk_output_dsi_enable(struct mtk_dsi *dsi) +{ + int ret; + + if (dsi->enabled == true) + return 0; + + ret = mtk_dsi_poweron(dsi); + if (ret < 0) + return ret; + + dsi_rxtx_control(dsi); + + dsi_clk_ulp_mode_leave(dsi); + dsi_lane0_ulp_mode(dsi, 0); + dsi_clk_hs_mode(dsi, 0); + dsi_set_mode(dsi); + + dsi_ps_control_vact(dsi); + dsi_config_vdo_timing(dsi); + + dsi_set_mode(dsi); + dsi_clk_hs_mode(dsi, 1); + + mtk_dsi_start(dsi); + + dsi->enabled = true; + + return 0; +} + +static int mtk_output_dsi_disable(struct mtk_dsi *dsi) +{ + if (dsi->enabled == false) + return 0; + + dsi_lane0_ulp_mode(dsi, 1); + dsi_clk_ulp_mode_enter(dsi); + mtk_dsi_poweroff(dsi); + dsi_phy_clk_switch_off(dsi); + + dsi->enabled = false; + + return 0; +} + +static void mtk_dsi_encoder_destroy(struct drm_encoder *encoder) +{ + drm_encoder_cleanup(encoder); +} + +static const struct drm_encoder_funcs mtk_dsi_encoder_funcs = { + .destroy = mtk_dsi_encoder_destroy, +}; + +static void mtk_dsi_encoder_dpms(struct drm_encoder *encoder, int mode) +{ + struct mtk_dsi *dsi = encoder_to_dsi(encoder); + struct drm_panel *panel = dsi->panel; + + mtk_dsi_info("%s dpms mode = %d !\n", __func__, mode); + + if (mode != DRM_MODE_DPMS_ON) { + drm_panel_disable(panel); + mtk_output_dsi_disable(dsi); + } else { + mtk_output_dsi_enable(dsi); + drm_panel_enable(panel); + } +} + +static bool mtk_dsi_encoder_mode_fixup(struct drm_encoder *encoder, + const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + return true; +} + +static void mtk_dsi_encoder_prepare(struct drm_encoder *encoder) +{ + /* drm framework doesn't check NULL. */ +} + +static void mtk_dsi_encoder_mode_set(struct drm_encoder *encoder, + struct drm_display_mode *mode, struct drm_display_mode *adjusted) +{ +} + +static void mtk_dsi_encoder_commit(struct drm_encoder *encoder) +{ + /* DRM_MODE_DPMS_ON? */ +} + +static enum drm_connector_status mtk_dsi_connector_detect( + struct drm_connector *connector, bool force) +{ + enum drm_connector_status status = connector_status_unknown; + + status = connector_status_connected; /* FIXME? */ + + return status; +} + +static void mtk_dsi_connector_destroy(struct drm_connector *connector) +{ + drm_connector_unregister(connector); + drm_connector_cleanup(connector); +} + +static const struct drm_display_mode default_modes[] = { + /* 1368x768@60Hz */ + { DRM_MODE("1368x768", DRM_MODE_TYPE_DRIVER, 72070, + 1368, 1368 + 58, 1368 + 58 + 58, 1368 + 58 + 58 + 58, 0, + 768, 768 + 4, 768 + 4 + 4, 768 + 4 + 4 + 4, 0, 0) }, +}; + +static int mtk_dsi_connector_get_modes(struct drm_connector *connector) +{ + const struct drm_display_mode *ptr = &default_modes[0]; + struct drm_display_mode *mode; + int count = 0; + + mode = drm_mode_duplicate(connector->dev, ptr); + if (mode) { + drm_mode_probed_add(connector, mode); + count++; + } + + connector->display_info.width_mm = mode->hdisplay; + connector->display_info.height_mm = mode->vdisplay; + + return 1; +} + +static struct drm_encoder * +mtk_dsi_connector_best_encoder(struct drm_connector *connector) +{ + struct mtk_dsi *dsi = connector_to_dsi(connector); + + return &dsi->encoder; +} + +static const struct drm_encoder_helper_funcs mtk_dsi_encoder_helper_funcs = { + .dpms = mtk_dsi_encoder_dpms, + .mode_fixup = mtk_dsi_encoder_mode_fixup, + .prepare = mtk_dsi_encoder_prepare, + .mode_set = mtk_dsi_encoder_mode_set, + .commit = mtk_dsi_encoder_commit, +}; + +static const struct drm_connector_funcs mtk_dsi_connector_funcs = { + .dpms = drm_helper_connector_dpms, + .detect = mtk_dsi_connector_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = mtk_dsi_connector_destroy, +}; + +static const struct drm_connector_helper_funcs + mtk_dsi_connector_helper_funcs = { + .get_modes = mtk_dsi_connector_get_modes, + .best_encoder = mtk_dsi_connector_best_encoder, +}; + +struct bridge_init { + struct i2c_client *mipirx_client; + struct i2c_client *dptx_client; + struct device_node *node_mipirx; + struct device_node *node_dptx; +}; + +static int mtk_drm_attach_lcm_bridge(struct drm_bridge *bridge, + struct drm_encoder *encoder) +{ + int ret; + + encoder->bridge = bridge; + bridge->encoder = encoder; + ret = drm_bridge_attach(encoder->dev, bridge); + if (ret) { + DRM_ERROR("Failed to attach bridge to drm\n"); + return ret; + } + + return 0; +} + +static int mtk_dsi_create_conn_enc(struct mtk_dsi *dsi) +{ + int ret; + + ret = drm_encoder_init(dsi->drm_dev, &dsi->encoder, + &mtk_dsi_encoder_funcs, DRM_MODE_ENCODER_DSI); + + if (ret) + goto errcode; + + drm_encoder_helper_add(&dsi->encoder, &mtk_dsi_encoder_helper_funcs); + + dsi->encoder.possible_crtcs = 1; + + /* Pre-empt DP connector creation if there's a bridge */ + ret = mtk_drm_attach_lcm_bridge(dsi->bridge, &dsi->encoder); + if (!ret) + return 0; + + ret = drm_connector_init(dsi->drm_dev, &dsi->conn, + &mtk_dsi_connector_funcs, DRM_MODE_CONNECTOR_DSI); + if (ret) + goto errcode; + + drm_connector_helper_add(&dsi->conn, &mtk_dsi_connector_helper_funcs); + + ret = drm_connector_register(&dsi->conn); + if (ret) + goto errcode; + + dsi->conn.dpms = DRM_MODE_DPMS_OFF; + dsi->conn.encoder = &dsi->encoder; + + drm_mode_connector_attach_encoder(&dsi->conn, &dsi->encoder); + + if (dsi->panel) + ret = drm_panel_attach(dsi->panel, &dsi->conn); + + return 0; + +errcode: + drm_encoder_cleanup(&dsi->encoder); + drm_connector_unregister(&dsi->conn); + drm_connector_cleanup(&dsi->conn); + + return ret; +} + +static void mtk_dsi_destroy_conn_enc(struct mtk_dsi *dsi) +{ + drm_encoder_cleanup(&dsi->encoder); + drm_connector_unregister(&dsi->conn); + drm_connector_cleanup(&dsi->conn); +} + +static int mtk_dsi_bind(struct device *dev, struct device *master, + void *data) +{ + int ret; + struct mtk_dsi *dsi = NULL; + + dsi = platform_get_drvdata(to_platform_device(dev)); + if (!dsi) { + ret = -EFAULT; + goto errcode; + } + + dsi->drm_dev = data; + + ret = mtk_dsi_create_conn_enc(dsi); + if (ret) { + DRM_ERROR("Encoder create failed with %d\n", ret); + return ret; + } + + return 0; + +errcode: + return ret; + +} + +static void mtk_dsi_unbind(struct device *dev, struct device *master, + void *data) +{ + struct mtk_dsi *dsi = NULL; + + dsi = platform_get_drvdata(to_platform_device(dev)); + mtk_dsi_destroy_conn_enc(dsi); + + dsi->drm_dev = NULL; +} + +static const struct component_ops mtk_dsi_component_ops = { + .bind = mtk_dsi_bind, + .unbind = mtk_dsi_unbind, +}; + +static int mtk_dsi_host_attach(struct mipi_dsi_host *host, + struct mipi_dsi_device *device) +{ + struct mtk_dsi *dsi = host_to_mtk(host); + + dsi->mode_flags = device->mode_flags; + dsi->format = device->format; + dsi->lanes = device->lanes; + + dsi->panel = of_drm_find_panel(device->dev.of_node); + if (dsi->panel) { + if (dsi->conn.dev) + drm_helper_hpd_irq_event(dsi->conn.dev); + } + + return 0; +} + +static int mtk_dsi_host_detach(struct mipi_dsi_host *host, + struct mipi_dsi_device *device) +{ + struct mtk_dsi *dsi = host_to_mtk(host); + + if (dsi->panel && &device->dev == dsi->panel->dev) { + if (dsi->conn.dev) + drm_helper_hpd_irq_event(dsi->conn.dev); + + dsi->panel = NULL; + } + + return 0; +} + +static const struct mipi_dsi_host_ops mtk_dsi_host_ops = { + .attach = mtk_dsi_host_attach, + .detach = mtk_dsi_host_detach, +}; + +static int mtk_dsi_probe(struct platform_device *pdev) +{ + struct mtk_dsi *dsi = NULL; + struct device *dev = &pdev->dev; + struct device_node *panel_node, *bridge_node, *endpoint; + struct resource *regs; + int err; + int ret; + + dsi = kzalloc(sizeof(struct mtk_dsi), GFP_KERNEL); + + dsi->mode_flags = MIPI_DSI_MODE_VIDEO; + dsi->format = MIPI_DSI_FMT_RGB888; + dsi->lanes = 4; + + dsi->vm.pixelclock = 76000; + dsi->vm.hactive = 1368; + dsi->vm.hback_porch = 100; + dsi->vm.hfront_porch = 106; + dsi->vm.hsync_len = 26; + dsi->vm.vactive = 768; + dsi->vm.vback_porch = 10; + dsi->vm.vfront_porch = 10; + dsi->vm.vsync_len = 12; + + err = mtk_dsi_of_read_u32(dev->of_node, "mediatek,width", + &dsi->vm.hactive); + if (err < 0) + return err; + + err = mtk_dsi_of_read_u32(dev->of_node, "mediatek,height", + &dsi->vm.vactive); + if (err < 0) + return err; + + err = mtk_dsi_of_read_u32(dev->of_node, "mediatek,mipi-tx-burst-freq", + &dsi->pll_clk_rate); + + if (err < 0) + return err; + + endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); + if (endpoint) { + bridge_node = of_graph_get_remote_port_parent(endpoint); + if (!bridge_node) + return -EPROBE_DEFER; + + dsi->bridge = of_drm_find_bridge(bridge_node); + of_node_put(bridge_node); + if (!dsi->bridge) + return -EPROBE_DEFER; + } + + dsi->dsi0_engine_clk_cg = devm_clk_get(dev, "dsi0_engine_disp_ck"); + if (IS_ERR(dsi->dsi0_engine_clk_cg)) { + dev_err(dev, "cannot get dsi0_engine_clk_cg\n"); + return PTR_ERR(dsi->dsi0_engine_clk_cg); + } + + dsi->dsi0_digital_clk_cg = devm_clk_get(dev, "dsi0_digital_disp_ck"); + if (IS_ERR(dsi->dsi0_digital_clk_cg)) { + dev_err(dev, "cannot get dsi0_digital_disp_ck\n"); + return PTR_ERR(dsi->dsi0_digital_clk_cg); + } + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); + dsi->dsi_reg_base = devm_ioremap_resource(dev, regs); + + if (IS_ERR(dsi->dsi_reg_base)) { + dev_err(dev, "cannot get dsi->dsi_reg_base\n"); + return PTR_ERR(dsi->dsi_reg_base); + } + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 1); + dsi->dsi_tx_reg_base = devm_ioremap_resource(dev, regs); + if (IS_ERR(dsi->dsi_tx_reg_base)) { + dev_err(dev, "cannot get dsi->dsi_tx_reg_base\n"); + return PTR_ERR(dsi->dsi_tx_reg_base); + } + + dsi->disp_supplies = devm_regulator_get(&pdev->dev, "disp-bdg"); + if (IS_ERR(dsi->disp_supplies)) { + dev_err(dev, "cannot get dsi->disp_supplies\n"); + return PTR_ERR(dsi->disp_supplies); + } + + ret = regulator_set_voltage(dsi->disp_supplies, 1800000, 1800000); + if (ret != 0) { + dev_err(dev, "lcm failed to set lcm_vgp voltage: %d\n", ret); + return PTR_ERR(dsi->disp_supplies); + } + + ret = regulator_enable(dsi->disp_supplies); + if (ret != 0) { + dev_err(dev, "Failed to enable lcm_vgp: %d\n", ret); + return PTR_ERR(dsi->disp_supplies); + } + + panel_node = of_parse_phandle(dev->of_node, "mediatek,panel", 0); + if (panel_node) { + dsi->panel = of_drm_find_panel(panel_node); + of_node_put(panel_node); + if (!dsi->panel) + return -EPROBE_DEFER; + } else + return -EPROBE_DEFER; + + platform_set_drvdata(pdev, dsi); + + ret = component_add(&pdev->dev, &mtk_dsi_component_ops); + if (ret) + goto err_del_component; + + return 0; + +err_del_component: + component_del(&pdev->dev, &mtk_dsi_component_ops); + return -EPROBE_DEFER; + +} + +static int mtk_dsi_remove(struct platform_device *pdev) +{ + struct mtk_dsi *dsi = platform_get_drvdata(pdev); + + mtk_output_dsi_disable(dsi); + component_del(&pdev->dev, &mtk_dsi_component_ops); + + return 0; +} + +static const struct of_device_id mtk_dsi_of_match[] = { + { .compatible = "mediatek,mt8173-dsi" }, + { }, +}; + +struct platform_driver mtk_dsi_driver = { + .probe = mtk_dsi_probe, + .remove = mtk_dsi_remove, + .driver = { + .name = "mtk-dsi", + .of_match_table = mtk_dsi_of_match, + .owner = THIS_MODULE, + }, +}; + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_dsi.h b/drivers/gpu/drm/mediatek/mediatek_drm_dsi.h new file mode 100644 index 0000000..7b7b93b --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_dsi.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + +#ifndef _MEDIATEK_DRM_DSI_H_ +#define _MEDIATEK_DRM_DSI_H_ + + +struct mtk_dsi { + struct drm_device *drm_dev; + struct drm_encoder encoder; + struct drm_connector conn; + struct drm_panel *panel; + struct drm_bridge *bridge; + struct mipi_dsi_host host; + struct regulator *disp_supplies; + + void __iomem *dsi_reg_base; + void __iomem *dsi_tx_reg_base; + + struct clk *dsi_disp_clk_cg; + struct clk *dsi_dsi_clk_cg; + struct clk *dsi_div2_clk_cg; + + struct clk *dsi0_engine_clk_cg; + struct clk *dsi0_digital_clk_cg; + + u32 pll_clk_rate; + + unsigned long mode_flags; + enum mipi_dsi_pixel_format format; + unsigned int lanes; + struct videomode vm; + bool enabled; +}; + + +static inline struct mtk_dsi *host_to_mtk(struct mipi_dsi_host *host) +{ + return container_of(host, struct mtk_dsi, host); +} + +static inline struct mtk_dsi *encoder_to_dsi(struct drm_encoder *e) +{ + return container_of(e, struct mtk_dsi, encoder); +} + +#define connector_to_dsi(c) container_of(c, struct mtk_dsi, conn) + + +#define mtk_dsi_err(fmt, ...) \ + pr_err("[mediatek drm dsi] ERROR!!! fun:%s, line:%d " \ + fmt, __func__, __LINE__, ##__VA_ARGS__) +#define mtk_dsi_info(fmt, ...) \ + pr_info("[mediatek drm dsi] INFO fun:%s, line:%d " \ + fmt, __func__, __LINE__, ##__VA_ARGS__) +#define mtk_dsi_output(fmt, ...) \ + pr_info(fmt, ##__VA_ARGS__) + +#endif + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_fb.c b/drivers/gpu/drm/mediatek/mediatek_drm_fb.c new file mode 100644 index 0000000..fbaba95 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_fb.c @@ -0,0 +1,339 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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 <drm/drm_gem.h> +#include <drm/drm_crtc_helper.h> +#include <drm/drm_fb_helper.h> + +#include "mediatek_drm_drv.h" +#include "mediatek_drm_fb.h" +#include "mediatek_drm_gem.h" + + +static int mtk_drm_fb_create_handle(struct drm_framebuffer *fb, + struct drm_file *file_priv, + unsigned int *handle) +{ + struct mtk_drm_fb *mtk_fb = to_mtk_fb(fb); + + return drm_gem_handle_create(file_priv, mtk_fb->gem_obj[0], handle); +} + +static void mtk_drm_fb_destroy(struct drm_framebuffer *fb) +{ + unsigned int i; + struct mtk_drm_fb *mtk_fb = to_mtk_fb(fb); + struct drm_gem_object *gem; + int nr = drm_format_num_planes(fb->pixel_format); + + drm_framebuffer_cleanup(fb); + + for (i = 0; i < nr; i++) { + gem = mtk_fb->gem_obj[i]; + drm_gem_object_unreference_unlocked(gem); + } +} + +static struct drm_framebuffer_funcs mediatek_drm_fb_funcs = { + .create_handle = mtk_drm_fb_create_handle, + .destroy = mtk_drm_fb_destroy, +}; + +static struct mtk_drm_fb *mtk_drm_framebuffer_init(struct drm_device *dev, + struct drm_mode_fb_cmd2 *mode, + struct drm_gem_object **obj) +{ + struct mtk_drm_fb *mtk_fb; + unsigned int i; + int ret; + + mtk_fb = devm_kzalloc(dev->dev, sizeof(*mtk_fb), GFP_KERNEL); + if (!mtk_fb) + return ERR_PTR(-ENOMEM); + + drm_helper_mode_fill_fb_struct(&mtk_fb->base, mode); + + for (i = 0; i < drm_format_num_planes(mode->pixel_format); i++) + mtk_fb->gem_obj[i] = obj[i]; + + ret = drm_framebuffer_init(dev, &mtk_fb->base, &mediatek_drm_fb_funcs); + if (ret) { + DRM_ERROR("failed to initialize framebuffer\n"); + return ERR_PTR(ret); + } + + return mtk_fb; +} + +static int mtk_drm_fb_mmap(struct fb_info *info, struct vm_area_struct *vma) +{ + struct drm_fb_helper *helper = info->par; + struct device *dev = ((struct drm_device *)helper->dev)->dev; + struct mtk_drm_fb *mtk_fb = to_mtk_fb(helper->fb); + struct mtk_drm_gem_buf *buffer = + to_mtk_gem_obj(mtk_fb->gem_obj[0])->buffer; + int ret; + + vma->vm_flags |= VM_MIXEDMAP; + + if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, &buffer->dma_attrs)) { + ret = dma_mmap_attrs(dev, vma, buffer->pages, + buffer->mva_addr, buffer->size, &buffer->dma_attrs); + } else { + ret = dma_mmap_attrs(dev, vma, buffer->kvaddr, + buffer->mva_addr, buffer->size, &buffer->dma_attrs); + } + + if (ret) { + DRM_ERROR("failed to fb_mmap %d\n", ret); + return ret; + } + + return 0; +} + +static struct fb_ops mediatek_fb_ops = { + .owner = THIS_MODULE, + .fb_fillrect = sys_fillrect, + .fb_copyarea = sys_copyarea, + .fb_imageblit = sys_imageblit, + .fb_check_var = drm_fb_helper_check_var, + .fb_set_par = drm_fb_helper_set_par, + .fb_blank = drm_fb_helper_blank, + .fb_pan_display = drm_fb_helper_pan_display, + .fb_setcmap = drm_fb_helper_setcmap, + .fb_mmap = mtk_drm_fb_mmap, +}; + +static int mtk_fbdev_probe(struct drm_fb_helper *helper, + struct drm_fb_helper_surface_size *sizes) +{ + struct drm_device *dev = helper->dev; + struct drm_mode_fb_cmd2 mode = { 0 }; + struct mtk_drm_fb *mtk_fb; + struct mtk_drm_gem_buf *buffer; + struct mtk_drm_gem_obj *mtk_gem; + struct drm_gem_object *gem; + struct fb_info *info; + struct drm_framebuffer *fb; + unsigned long offset; + size_t size; + int err; + + mode.width = sizes->surface_width; + mode.height = sizes->surface_height; + mode.pitches[0] = sizes->surface_width * ((sizes->surface_bpp + 7) / 8); + mode.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp, + sizes->surface_depth); + + mode.height = mode.height;/* << 1; for fb use? */ + size = mode.pitches[0] * mode.height; + dev_info(dev->dev, "mtk_fbdev_probe %dx%d bpp %d pitch %d size %zu\n", + mode.width, mode.height, sizes->surface_bpp, mode.pitches[0], + size); + + mtk_gem = mtk_drm_gem_create(dev, 3, size); + if (IS_ERR(mtk_gem)) { + err = PTR_ERR(mtk_gem); + goto fini; + } + + gem = &mtk_gem->base; + buffer = mtk_gem->buffer; + + mtk_fb = mtk_drm_framebuffer_init(dev, &mode, &gem); + if (IS_ERR(mtk_fb)) { + dev_err(dev->dev, "failed to allocate DRM framebuffer\n"); + err = PTR_ERR(mtk_fb); + goto free; + } + fb = &mtk_fb->base; + + info = framebuffer_alloc(0, dev->dev); + if (!info) { + dev_err(dev->dev, "failed to allocate framebuffer info\n"); + err = PTR_ERR(info); + goto release; + } + + helper->fb = fb; + helper->fbdev = info; + + info->par = helper; + info->flags = FBINFO_FLAG_DEFAULT; + info->fbops = &mediatek_fb_ops; + + err = fb_alloc_cmap(&info->cmap, 256, 0); + if (err < 0) { + dev_err(dev->dev, "failed to allocate color map: %d\n", err); + goto destroy; + } + + drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth); + drm_fb_helper_fill_var(info, helper, fb->width, fb->height); + + offset = info->var.xoffset * (fb->bits_per_pixel + 7) / 8; + offset += info->var.yoffset * fb->pitches[0]; + + strcpy(info->fix.id, "mtk"); + /* dev->mode_config.fb_base = (resource_size_t)bo->paddr; */ + info->var.yres = info->var.yres_virtual;/* >> 1; for fb use? */ + info->fix.smem_start = buffer->mva_addr + offset; + info->fix.smem_len = size; + info->screen_base = buffer->kvaddr + offset; + info->screen_size = size; + + return 0; + +destroy: + drm_framebuffer_unregister_private(fb); + mtk_drm_fb_destroy(fb); +release: + framebuffer_release(info); +free: + mtk_drm_gem_free_object(&mtk_gem->base); +fini: + dev_err(dev->dev, "mtk_fbdev_probe fail\n"); + return err; +} + +static struct drm_fb_helper_funcs mediatek_drm_fb_helper_funcs = { + .fb_probe = mtk_fbdev_probe, +}; + +int mtk_fbdev_create(struct drm_device *dev) +{ + struct mtk_drm_private *priv = + (struct mtk_drm_private *)dev->dev_private; + struct drm_fb_helper *fbdev; + int ret; + + fbdev = devm_kzalloc(dev->dev, sizeof(*fbdev), GFP_KERNEL); + if (!fbdev) + return -ENOMEM; + + drm_fb_helper_prepare(dev, fbdev, &mediatek_drm_fb_helper_funcs); + + ret = drm_fb_helper_init(dev, fbdev, dev->mode_config.num_crtc, + dev->mode_config.num_connector); + if (ret) { + dev_err(dev->dev, "failed to initialize DRM FB helper\n"); + goto fini; + } + + ret = drm_fb_helper_single_add_all_connectors(fbdev); + if (ret) { + dev_err(dev->dev, "failed to add connectors\n"); + goto fini; + } + + drm_helper_disable_unused_functions(dev); + + ret = drm_fb_helper_initial_config(fbdev, FBDEV_BPP); + if (ret) { + dev_err(dev->dev, "failed to set initial configuration\n"); + goto fini; + } + priv->fb_helper = fbdev; + + return 0; + +fini: + drm_fb_helper_fini(fbdev); + + return ret; +} + +void mtk_fbdev_destroy(struct drm_device *dev) +{ + struct mtk_drm_private *priv = + (struct mtk_drm_private *)dev->dev_private; + struct drm_fb_helper *fbdev = priv->fb_helper; + struct fb_info *info = priv->fb_helper->fbdev; + + if (info) { + int err; + + err = unregister_framebuffer(info); + if (err < 0) + DRM_DEBUG_KMS("failed to unregister framebuffer\n"); + + if (info->cmap.len) + fb_dealloc_cmap(&info->cmap); + + framebuffer_release(info); + } + + if (fbdev->fb) { + drm_framebuffer_unregister_private(fbdev->fb); + mtk_drm_fb_destroy(fbdev->fb); + } + + drm_fb_helper_fini(fbdev); + kfree(fbdev); +} + +void mtk_drm_mode_output_poll_changed(struct drm_device *dev) +{ + struct mtk_drm_private *priv = + (struct mtk_drm_private *)dev->dev_private; + + if (priv->fb_helper) + drm_fb_helper_hotplug_event(priv->fb_helper); +} + +struct drm_framebuffer *mtk_drm_mode_fb_create(struct drm_device *dev, + struct drm_file *file, + struct drm_mode_fb_cmd2 *cmd) +{ + unsigned int hsub, vsub, i; + struct mtk_drm_fb *mtk_fb; + struct drm_gem_object *gem[MAX_FB_OBJ]; + int err; + + hsub = drm_format_horz_chroma_subsampling(cmd->pixel_format); + vsub = drm_format_vert_chroma_subsampling(cmd->pixel_format); + for (i = 0; i < drm_format_num_planes(cmd->pixel_format); i++) { + unsigned int width = cmd->width / (i ? hsub : 1); + unsigned int height = cmd->height / (i ? vsub : 1); + unsigned int size, bpp; + + gem[i] = drm_gem_object_lookup(dev, file, cmd->handles[i]); + if (!gem[i]) { + err = -ENOENT; + goto unreference; + } + + bpp = drm_format_plane_cpp(cmd->pixel_format, i); + size = (height - 1) * cmd->pitches[i] + width * bpp; + size += cmd->offsets[i]; + + if (gem[i]->size < size) { + err = -EINVAL; + goto unreference; + } + } + + mtk_fb = mtk_drm_framebuffer_init(dev, cmd, gem); + + return &mtk_fb->base; + +unreference: + while (i--) + drm_gem_object_unreference_unlocked(gem[i]); + + return ERR_PTR(err); +} + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_fb.h b/drivers/gpu/drm/mediatek/mediatek_drm_fb.h new file mode 100644 index 0000000..ee8b6a6 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_fb.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + +#ifndef _MEDIATEK_DRM_FB_H_ +#define _MEDIATEK_DRM_FB_H_ + +#define MAX_FB_OBJ 4 +#define FBDEV_BPP 16 + +/* + * mtk specific framebuffer structure. + * + * @fb: drm framebuffer object. + * @mtk_gem_obj: array of mtk specific gem object containing a gem object. + */ +struct mtk_drm_fb { + struct drm_framebuffer base; + struct drm_gem_object *gem_obj[MAX_FB_OBJ]; /* FIXME? mtk_gem_obj? */ +}; + +#define to_mtk_fb(x) container_of(x, struct mtk_drm_fb, base) + +void mtk_drm_mode_output_poll_changed(struct drm_device *dev); +struct drm_framebuffer *mtk_drm_mode_fb_create(struct drm_device *dev, + struct drm_file *file, + struct drm_mode_fb_cmd2 *cmd); + +int mtk_fbdev_create(struct drm_device *dev); +void mtk_fbdev_destroy(struct drm_device *dev); + +#endif + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_gem.c b/drivers/gpu/drm/mediatek/mediatek_drm_gem.c new file mode 100644 index 0000000..3df3f4f --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_gem.c @@ -0,0 +1,315 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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 <drm/drm_gem.h> + +#include "mediatek_drm_gem.h" +#include "drm/mediatek_drm.h" + + +struct mtk_drm_gem_obj *mtk_drm_gem_init(struct drm_device *dev, + unsigned long size) +{ + struct mtk_drm_gem_obj *mtk_gem_obj; + struct drm_gem_object *obj; + int ret; + + mtk_gem_obj = kzalloc(sizeof(*mtk_gem_obj), GFP_KERNEL); + if (!mtk_gem_obj) + return NULL; + + mtk_gem_obj->size = size; + obj = &mtk_gem_obj->base; + + ret = drm_gem_object_init(dev, obj, size); + if (ret < 0) { + DRM_ERROR("failed to initialize gem object\n"); + kfree(mtk_gem_obj); + return NULL; + } + + DRM_DEBUG_KMS("created file object = 0x%p\n", obj->filp); + + return mtk_gem_obj; +} + +struct mtk_drm_gem_obj *mtk_drm_gem_create(struct drm_device *dev, + unsigned int flags, unsigned long size) +{ + struct mtk_drm_gem_obj *mtk_gem; + struct mtk_drm_gem_buf *mtk_buf; + int ret; + + if (!size) { + DRM_ERROR("invalid size.\n"); + ret = -EINVAL; + goto err; + } + + mtk_gem = kzalloc(sizeof(*mtk_gem), GFP_KERNEL); + if (!mtk_gem) { + ret = -ENOMEM; + goto err; + } + + mtk_buf = kzalloc(sizeof(*mtk_buf), GFP_KERNEL); + if (!mtk_buf) { + ret = -ENOMEM; + goto err_buf; + } + mtk_gem->buffer = mtk_buf; + + if (flags == 0) { + size = round_up(size, PAGE_SIZE); + mtk_buf->kvaddr = kzalloc(size, GFP_KERNEL); + if (!mtk_buf->kvaddr) { + ret = -ENOMEM; + goto err_size; + } + + mtk_buf->paddr = virt_to_phys(mtk_buf->kvaddr); + mtk_buf->size = size; + mtk_buf->mva_addr = mtk_buf->paddr; + } else { + struct page **pages; + int npages, size_pages; + int offset, index; + + size = PAGE_ALIGN(size); + npages = size >> PAGE_SHIFT; + size_pages = npages * sizeof(*pages); + pages = kmalloc(size_pages, GFP_KERNEL); + if (!pages) { + ret = -ENOMEM; + goto err_size; + } + mtk_buf->pages = pages; + + init_dma_attrs(&mtk_buf->dma_attrs); + + mtk_buf->kvaddr = dma_alloc_attrs(dev->dev, size, + (dma_addr_t *)&mtk_buf->mva_addr, GFP_KERNEL, + &mtk_buf->dma_attrs); + if (!mtk_buf->kvaddr) { + ret = -ENOMEM; + goto err_mem; + } + + mtk_buf->paddr = 0; + mtk_buf->size = size; + + for (offset = 0, index = 0; + offset < size; offset += PAGE_SIZE, index++) + mtk_buf->pages[index] = + vmalloc_to_page(mtk_buf->kvaddr + offset); + + mtk_buf->sgt = drm_prime_pages_to_sg(mtk_buf->pages, npages); + } + mtk_gem->flags = flags; + + DRM_INFO("kvaddr = %p mva_addr = %X\n", + mtk_buf->kvaddr, mtk_buf->mva_addr); + ret = drm_gem_object_init(dev, &mtk_gem->base, size); + if (ret) + goto err_mem; + + return mtk_gem; + +err_mem: + if (mtk_buf->paddr) + kfree(mtk_buf->kvaddr); + else + dma_free_attrs(dev->dev, size, mtk_buf->kvaddr, + mtk_buf->mva_addr, &mtk_buf->dma_attrs); + + kfree(mtk_buf->pages); + +err_size: + kfree(mtk_buf); +err_buf: + kfree(mtk_gem); +err: + return ERR_PTR(ret); +} + +void mtk_drm_gem_free_object(struct drm_gem_object *gem) +{ + struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(gem); + + DRM_DEBUG_KMS("handle count = %d\n", gem->handle_count); + + drm_gem_free_mmap_offset(gem); + + /* release file pointer to gem object. */ + drm_gem_object_release(gem); + + if (mtk_gem->flags == 0) + kfree(mtk_gem->buffer->kvaddr); + else + dma_free_attrs(gem->dev->dev, mtk_gem->buffer->size, + mtk_gem->buffer->kvaddr, mtk_gem->buffer->mva_addr, + &mtk_gem->buffer->dma_attrs); + + kfree(mtk_gem->buffer->pages); + kfree(mtk_gem->buffer); + kfree(mtk_gem); +} + +int mtk_drm_gem_dumb_create(struct drm_file *file_priv, + struct drm_device *dev, + struct drm_mode_create_dumb *args) + +{ + struct mtk_drm_gem_obj *mtk_gem; + unsigned int min_pitch = args->width * ((args->bpp + 7) / 8); + int ret; + + args->pitch = min_pitch; + args->size = args->pitch * args->height; + + mtk_gem = mtk_drm_gem_create(dev, 3, args->size); + if (IS_ERR(mtk_gem)) + return PTR_ERR(mtk_gem); + + /* + * 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_priv, &mtk_gem->base, &args->handle); + if (ret) + return ret; + + /* drop reference from allocate - handle holds it now. */ + drm_gem_object_unreference_unlocked(&mtk_gem->base); + + return 0; +} + +int mtk_drm_gem_dumb_map_offset(struct drm_file *file_priv, + struct drm_device *dev, uint32_t handle, + uint64_t *offset) +{ + struct drm_gem_object *obj; + int ret = 0; + + 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. + */ + + obj = drm_gem_object_lookup(dev, file_priv, handle); + if (!obj) { + DRM_ERROR("failed to lookup gem object.\n"); + ret = -EINVAL; + goto unlock; + } + + ret = drm_gem_create_mmap_offset(obj); + if (ret) + goto out; + + *offset = drm_vma_node_offset_addr(&obj->vma_node); + DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset); + +out: + drm_gem_object_unreference(obj); +unlock: + mutex_unlock(&dev->struct_mutex); + return ret; +} + +int mtk_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma) +{ + struct mtk_drm_gem_obj *mtk_gem; + struct drm_gem_object *gem; + int ret; + + /* set vm_area_struct. */ + ret = drm_gem_mmap(filp, vma); + if (ret) { + DRM_ERROR("failed to mmap.\n"); + return ret; + } + + gem = vma->vm_private_data; + mtk_gem = to_mtk_gem_obj(gem); + + if (mtk_gem->flags == 0) { + /* + * get page frame number to physical memory to be mapped + * to user space. + */ + ret = remap_pfn_range(vma, vma->vm_start, + mtk_gem->buffer->paddr >> PAGE_SHIFT, + vma->vm_end - vma->vm_start, vma->vm_page_prot); + } else { + struct drm_file *file_priv = filp->private_data; + struct drm_device *dev = file_priv->minor->dev; + struct mtk_drm_gem_buf *buffer = mtk_gem->buffer; + + vma->vm_flags |= VM_MIXEDMAP; + + ret = dma_mmap_attrs(dev->dev, vma, buffer->kvaddr, + buffer->mva_addr, buffer->size, &buffer->dma_attrs); + if (ret) { + DRM_ERROR("failed to remap dma %d\n", ret); + return ret; + } + } + + if (ret) + drm_gem_vm_close(vma); + + return ret; +} + +int mediatek_gem_map_offset_ioctl(struct drm_device *drm, void *data, + struct drm_file *file_priv) +{ + struct drm_mtk_gem_map_off *args = data; + + return mtk_drm_gem_dumb_map_offset(file_priv, drm, args->handle, + &args->offset); +} + +int mediatek_gem_create_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv) +{ + struct mtk_drm_gem_obj *mtk_gem; + struct drm_mtk_gem_create *args = data; + int ret; + + mtk_gem = mtk_drm_gem_create(dev, 3, args->size); + + if (IS_ERR(mtk_gem)) + return PTR_ERR(mtk_gem); + + /* + * 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_priv, &mtk_gem->base, &args->handle); + if (ret) + return ret; + + /* drop reference from allocate - handle holds it now. */ + drm_gem_object_unreference_unlocked(&mtk_gem->base); + + return 0; +} + + diff --git a/drivers/gpu/drm/mediatek/mediatek_drm_gem.h b/drivers/gpu/drm/mediatek/mediatek_drm_gem.h new file mode 100644 index 0000000..1529481 --- /dev/null +++ b/drivers/gpu/drm/mediatek/mediatek_drm_gem.h @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + +#ifndef _MEDIATEK_DRM_GEM_H_ +#define _MEDIATEK_DRM_GEM_H_ + +#include <drm/drm_gem.h> + +struct drm_gem_object; + +/* + * mtk drm gem buffer structure. + * + * @kvaddr: kernel virtual address to allocated memory region. + * @dma_addr: bus address(accessed by dma) to allocated memory region. + * - this address could be physical address without IOMMU and + * device address with IOMMU. + * @sgt: sg table to transfer page data. + * @pages: contain all pages to allocated memory region. + * @size: size of allocated memory region. + */ +struct mtk_drm_gem_buf { + void __iomem *kvaddr; + dma_addr_t dma_addr; + struct dma_attrs dma_attrs; + struct sg_table *sgt; + struct page **pages; + unsigned long size; + unsigned int mva_addr; + unsigned int paddr; +}; + +/* + * mtk drm buffer structure. + * + * @base: a gem object. + * - a new handle to this gem object would be created + * by drm_gem_handle_create(). + * @buffer: a pointer to mtk_drm_gem_buffer object. + * - contain the information to memory region allocated + * by user request or at framebuffer creation. + * continuous memory region allocated by user request + * or at framebuffer creation. + * @size: total memory size to physically non-continuous memory region. + * @flags: indicate memory type to allocated buffer and cache attruibute. + * + * P.S. this object would be transferred to user as kms_bo.handle so + * user can access the buffer through kms_bo.handle. + */ +struct mtk_drm_gem_obj { + struct drm_gem_object base; + struct mtk_drm_gem_buf *buffer; + unsigned long size; + unsigned int flags; +}; + +#define to_mtk_gem_obj(x) container_of(x, struct mtk_drm_gem_obj, base) + +struct mtk_drm_gem_obj *mtk_drm_gem_init(struct drm_device *dev, + unsigned long size); +void mtk_drm_gem_free_object(struct drm_gem_object *gem); +struct mtk_drm_gem_obj *mtk_drm_gem_create(struct drm_device *dev, + unsigned int flags, unsigned long size); +int mtk_drm_gem_dumb_create(struct drm_file *file_priv, + struct drm_device *dev, struct drm_mode_create_dumb *args); +int mtk_drm_gem_dumb_map_offset(struct drm_file *file_priv, + struct drm_device *dev, uint32_t handle, uint64_t *offset); +int mtk_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); + +/* + * request gem object creation and buffer allocation as the size + * that it is calculated with framebuffer information such as width, + * height and bpp. + */ +int mediatek_gem_create_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv); + +/* get buffer offset to map to user space. */ +int mediatek_gem_map_offset_ioctl(struct drm_device *dev, void *data, + struct drm_file *file_priv); + + +#endif + diff --git a/include/uapi/drm/mediatek_drm.h b/include/uapi/drm/mediatek_drm.h new file mode 100644 index 0000000..19ea357 --- /dev/null +++ b/include/uapi/drm/mediatek_drm.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2015 MediaTek Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + */ + + +#ifndef _UAPI_MEDIATEK_DRM_H +#define _UAPI_MEDIATEK_DRM_H + +#include <drm/drm.h> + +/** + * User-desired buffer creation information structure. + * + * @size: user-desired memory allocation size. + * - this size value would be page-aligned internally. + * @flags: user request for setting memory type or cache attributes. + * @handle: returned a handle to created gem object. + * - this handle will be set by gem module of kernel side. + */ +struct drm_mtk_gem_create { + uint64_t size; + uint32_t flags; + uint32_t handle; +}; + +/** + * A structure for getting buffer offset. + * + * @handle: a pointer to gem object created. + * @pad: just padding to be 64-bit aligned. + * @offset: relatived offset value of the memory region allocated. + * - this value should be set by user. + */ +struct drm_mtk_gem_map_off { + uint32_t handle; + uint32_t pad; + uint64_t offset; +}; + +#define DRM_MTK_GEM_CREATE 0x00 +#define DRM_MTK_GEM_MAP_OFFSET 0x01 + +#define DRM_IOCTL_MTK_GEM_CREATE DRM_IOWR(DRM_COMMAND_BASE + \ + DRM_MTK_GEM_CREATE, struct drm_mtk_gem_create) + +#define DRM_IOCTL_MTK_GEM_MAP_OFFSET DRM_IOWR(DRM_COMMAND_BASE + \ + DRM_MTK_GEM_MAP_OFFSET, struct drm_mtk_gem_map_off) + + +#endif /* _UAPI_MEDIATEK_DRM_H */