blob: 411e90a7813a48e32bc44a9e4334d92a9e9dc7bc [file] [log] [blame]
Inki Dae1c248b72011-10-04 19:19:01 +09001/* exynos_drm_fimd.c
2 *
3 * Copyright (C) 2011 Samsung Electronics Co.Ltd
4 * Authors:
5 * Joonyoung Shim <jy0922.shim@samsung.com>
6 * Inki Dae <inki.dae@samsung.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
David Howells760285e2012-10-02 18:01:07 +010014#include <drm/drmP.h>
Inki Dae1c248b72011-10-04 19:19:01 +090015
16#include <linux/kernel.h>
Inki Dae1c248b72011-10-04 19:19:01 +090017#include <linux/platform_device.h>
18#include <linux/clk.h>
Sachin Kamat3f1c7812013-08-14 16:38:01 +053019#include <linux/of.h>
Joonyoung Shimd636ead2012-12-14 15:48:25 +090020#include <linux/of_device.h>
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +090021#include <linux/pm_runtime.h>
Inki Dae1c248b72011-10-04 19:19:01 +090022
Vikas Sajjan7f4596f2013-03-07 12:15:21 +053023#include <video/of_display_timing.h>
Andrzej Hajda111e6052013-08-21 16:22:01 +020024#include <video/of_videomode.h>
Leela Krishna Amudala5a213a52012-08-08 09:44:49 +090025#include <video/samsung_fimd.h>
Inki Dae1c248b72011-10-04 19:19:01 +090026#include <drm/exynos_drm.h>
Inki Dae1c248b72011-10-04 19:19:01 +090027
28#include "exynos_drm_drv.h"
29#include "exynos_drm_fbdev.h"
30#include "exynos_drm_crtc.h"
Inki Daebcc5cd12012-10-19 17:16:36 +090031#include "exynos_drm_iommu.h"
Inki Dae1c248b72011-10-04 19:19:01 +090032
33/*
Sachin Kamatb8654b32013-09-19 10:39:44 +053034 * FIMD stands for Fully Interactive Mobile Display and
Inki Dae1c248b72011-10-04 19:19:01 +090035 * as a display controller, it transfers contents drawn on memory
36 * to a LCD Panel through Display Interfaces such as RGB or
37 * CPU Interface.
38 */
39
Andrzej Hajda111e6052013-08-21 16:22:01 +020040#define FIMD_DEFAULT_FRAMERATE 60
41
Inki Dae1c248b72011-10-04 19:19:01 +090042/* position control register for hardware window 0, 2 ~ 4.*/
43#define VIDOSD_A(win) (VIDOSD_BASE + 0x00 + (win) * 16)
44#define VIDOSD_B(win) (VIDOSD_BASE + 0x04 + (win) * 16)
Leela Krishna Amudala0f10cf12013-03-07 23:28:52 -050045/*
46 * size control register for hardware windows 0 and alpha control register
47 * for hardware windows 1 ~ 4
48 */
49#define VIDOSD_C(win) (VIDOSD_BASE + 0x08 + (win) * 16)
50/* size control register for hardware windows 1 ~ 2. */
Inki Dae1c248b72011-10-04 19:19:01 +090051#define VIDOSD_D(win) (VIDOSD_BASE + 0x0C + (win) * 16)
52
53#define VIDWx_BUF_START(win, buf) (VIDW_BUF_START(buf) + (win) * 8)
54#define VIDWx_BUF_END(win, buf) (VIDW_BUF_END(buf) + (win) * 8)
55#define VIDWx_BUF_SIZE(win, buf) (VIDW_BUF_SIZE(buf) + (win) * 4)
56
57/* color key control register for hardware window 1 ~ 4. */
Leela Krishna Amudala0f10cf12013-03-07 23:28:52 -050058#define WKEYCON0_BASE(x) ((WKEYCON0 + 0x140) + ((x - 1) * 8))
Inki Dae1c248b72011-10-04 19:19:01 +090059/* color key value register for hardware window 1 ~ 4. */
Leela Krishna Amudala0f10cf12013-03-07 23:28:52 -050060#define WKEYCON1_BASE(x) ((WKEYCON1 + 0x140) + ((x - 1) * 8))
Inki Dae1c248b72011-10-04 19:19:01 +090061
62/* FIMD has totally five hardware windows. */
63#define WINDOWS_NR 5
64
Sean Paulbb7704d2014-01-30 16:19:06 -050065#define get_fimd_manager(mgr) platform_get_drvdata(to_platform_device(dev))
Inki Dae1c248b72011-10-04 19:19:01 +090066
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +053067struct fimd_driver_data {
68 unsigned int timing_base;
Tomasz Figade7af102013-05-01 21:02:27 +020069
70 unsigned int has_shadowcon:1;
Tomasz Figa411d9ed2013-05-01 21:02:28 +020071 unsigned int has_clksel:1;
Inki Dae5cc46212013-08-20 14:28:56 +090072 unsigned int has_limited_fmt:1;
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +053073};
74
Tomasz Figa725ddea2013-05-01 21:02:29 +020075static struct fimd_driver_data s3c64xx_fimd_driver_data = {
76 .timing_base = 0x0,
77 .has_clksel = 1,
Inki Dae5cc46212013-08-20 14:28:56 +090078 .has_limited_fmt = 1,
Tomasz Figa725ddea2013-05-01 21:02:29 +020079};
80
Sachin Kamat6ecf18f2012-11-19 15:22:54 +053081static struct fimd_driver_data exynos4_fimd_driver_data = {
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +053082 .timing_base = 0x0,
Tomasz Figade7af102013-05-01 21:02:27 +020083 .has_shadowcon = 1,
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +053084};
85
Sachin Kamat6ecf18f2012-11-19 15:22:54 +053086static struct fimd_driver_data exynos5_fimd_driver_data = {
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +053087 .timing_base = 0x20000,
Tomasz Figade7af102013-05-01 21:02:27 +020088 .has_shadowcon = 1,
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +053089};
90
Inki Dae1c248b72011-10-04 19:19:01 +090091struct fimd_win_data {
92 unsigned int offset_x;
93 unsigned int offset_y;
Inki Dae19c8b832011-10-14 13:29:46 +090094 unsigned int ovl_width;
95 unsigned int ovl_height;
96 unsigned int fb_width;
97 unsigned int fb_height;
Inki Dae1c248b72011-10-04 19:19:01 +090098 unsigned int bpp;
Inki Daea4f38a82013-08-20 13:51:02 +090099 unsigned int pixel_format;
Inki Dae2c871122011-11-12 15:23:32 +0900100 dma_addr_t dma_addr;
Inki Dae1c248b72011-10-04 19:19:01 +0900101 unsigned int buf_offsize;
102 unsigned int line_size; /* bytes */
Inki Daeec05da92011-12-06 11:06:54 +0900103 bool enabled;
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530104 bool resume;
Inki Dae1c248b72011-10-04 19:19:01 +0900105};
106
107struct fimd_context {
108 struct exynos_drm_subdrv subdrv;
Sean Paulbb7704d2014-01-30 16:19:06 -0500109 struct device *dev;
Sean Paul40c8ab42014-01-30 16:19:04 -0500110 struct drm_device *drm_dev;
Inki Dae1c248b72011-10-04 19:19:01 +0900111 int irq;
112 struct drm_crtc *crtc;
113 struct clk *bus_clk;
114 struct clk *lcd_clk;
Inki Dae1c248b72011-10-04 19:19:01 +0900115 void __iomem *regs;
116 struct fimd_win_data win_data[WINDOWS_NR];
117 unsigned int clkdiv;
118 unsigned int default_win;
119 unsigned long irq_flags;
120 u32 vidcon0;
121 u32 vidcon1;
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +0900122 bool suspended;
Inki Daec32b06e2011-12-16 21:49:03 +0900123 struct mutex lock;
Prathyush K01ce1132012-12-06 20:16:04 +0530124 wait_queue_head_t wait_vsync_queue;
125 atomic_t wait_vsync_event;
Inki Dae1c248b72011-10-04 19:19:01 +0900126
Andrzej Hajda562ad9f2013-08-21 16:22:03 +0200127 struct exynos_drm_panel_info panel;
Tomasz Figa18873462013-05-01 21:02:26 +0200128 struct fimd_driver_data *driver_data;
Inki Dae1c248b72011-10-04 19:19:01 +0900129};
130
Joonyoung Shimd636ead2012-12-14 15:48:25 +0900131static const struct of_device_id fimd_driver_dt_match[] = {
Tomasz Figa725ddea2013-05-01 21:02:29 +0200132 { .compatible = "samsung,s3c6400-fimd",
133 .data = &s3c64xx_fimd_driver_data },
Vikas Sajjan5830daf2013-02-27 16:02:58 +0530134 { .compatible = "samsung,exynos4210-fimd",
Joonyoung Shimd636ead2012-12-14 15:48:25 +0900135 .data = &exynos4_fimd_driver_data },
Vikas Sajjan5830daf2013-02-27 16:02:58 +0530136 { .compatible = "samsung,exynos5250-fimd",
Joonyoung Shimd636ead2012-12-14 15:48:25 +0900137 .data = &exynos5_fimd_driver_data },
138 {},
139};
Joonyoung Shimd636ead2012-12-14 15:48:25 +0900140
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +0530141static inline struct fimd_driver_data *drm_fimd_get_driver_data(
142 struct platform_device *pdev)
143{
Joonyoung Shimd636ead2012-12-14 15:48:25 +0900144 const struct of_device_id *of_id =
145 of_match_device(fimd_driver_dt_match, &pdev->dev);
146
Sachin Kamat2d3f1732013-08-28 10:47:58 +0530147 return (struct fimd_driver_data *)of_id->data;
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +0530148}
149
Inki Dae1c248b72011-10-04 19:19:01 +0900150static bool fimd_display_is_connected(struct device *dev)
151{
Inki Dae1c248b72011-10-04 19:19:01 +0900152 /* TODO. */
153
154 return true;
155}
156
Eun-Chul Kim607c50d2012-02-14 15:59:46 +0900157static void *fimd_get_panel(struct device *dev)
Inki Dae1c248b72011-10-04 19:19:01 +0900158{
Sean Paulbb7704d2014-01-30 16:19:06 -0500159 struct exynos_drm_manager *mgr = get_fimd_manager(dev);
160 struct fimd_context *ctx = mgr->ctx;
Inki Dae1c248b72011-10-04 19:19:01 +0900161
Andrzej Hajda562ad9f2013-08-21 16:22:03 +0200162 return &ctx->panel;
Inki Dae1c248b72011-10-04 19:19:01 +0900163}
164
Rahul Sharma16844fb2013-06-10 14:50:00 +0530165static int fimd_check_mode(struct device *dev, struct drm_display_mode *mode)
Inki Dae1c248b72011-10-04 19:19:01 +0900166{
Inki Dae1c248b72011-10-04 19:19:01 +0900167 /* TODO. */
168
169 return 0;
170}
171
172static int fimd_display_power_on(struct device *dev, int mode)
173{
Inki Daeec05da92011-12-06 11:06:54 +0900174 /* TODO */
Inki Dae1c248b72011-10-04 19:19:01 +0900175
176 return 0;
177}
178
Inki Dae74ccc532011-10-19 17:23:07 +0900179static struct exynos_drm_display_ops fimd_display_ops = {
Inki Dae1c248b72011-10-04 19:19:01 +0900180 .type = EXYNOS_DISPLAY_TYPE_LCD,
181 .is_connected = fimd_display_is_connected,
Eun-Chul Kim607c50d2012-02-14 15:59:46 +0900182 .get_panel = fimd_get_panel,
Rahul Sharma16844fb2013-06-10 14:50:00 +0530183 .check_mode = fimd_check_mode,
Inki Dae1c248b72011-10-04 19:19:01 +0900184 .power_on = fimd_display_power_on,
185};
186
Sean Paulbb7704d2014-01-30 16:19:06 -0500187static int fimd_mgr_initialize(struct exynos_drm_manager *mgr,
188 struct drm_device *drm_dev)
Sean Paul40c8ab42014-01-30 16:19:04 -0500189{
Sean Paulbb7704d2014-01-30 16:19:06 -0500190 struct fimd_context *ctx = mgr->ctx;
Sean Paul40c8ab42014-01-30 16:19:04 -0500191
192 ctx->drm_dev = drm_dev;
193
194 return 0;
195}
196
Sean Paulbb7704d2014-01-30 16:19:06 -0500197static void fimd_dpms(struct exynos_drm_manager *mgr, int mode)
Inki Daeec05da92011-12-06 11:06:54 +0900198{
Sean Paulbb7704d2014-01-30 16:19:06 -0500199 struct fimd_context *ctx = mgr->ctx;
Inki Daec32b06e2011-12-16 21:49:03 +0900200
YoungJun Chobca34c92013-06-12 10:40:52 +0900201 DRM_DEBUG_KMS("%d\n", mode);
Inki Daeec05da92011-12-06 11:06:54 +0900202
Inki Daec32b06e2011-12-16 21:49:03 +0900203 mutex_lock(&ctx->lock);
204
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +0900205 switch (mode) {
206 case DRM_MODE_DPMS_ON:
Inki Daec32b06e2011-12-16 21:49:03 +0900207 /*
208 * enable fimd hardware only if suspended status.
209 *
210 * P.S. fimd_dpms function would be called at booting time so
211 * clk_enable could be called double time.
212 */
213 if (ctx->suspended)
Sean Paulbb7704d2014-01-30 16:19:06 -0500214 pm_runtime_get_sync(ctx->dev);
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +0900215 break;
216 case DRM_MODE_DPMS_STANDBY:
217 case DRM_MODE_DPMS_SUSPEND:
218 case DRM_MODE_DPMS_OFF:
Inki Dae373af0c2012-01-27 11:54:58 +0900219 if (!ctx->suspended)
Sean Paulbb7704d2014-01-30 16:19:06 -0500220 pm_runtime_put_sync(ctx->dev);
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +0900221 break;
222 default:
223 DRM_DEBUG_KMS("unspecified mode %d\n", mode);
224 break;
225 }
Inki Daec32b06e2011-12-16 21:49:03 +0900226
227 mutex_unlock(&ctx->lock);
Inki Daeec05da92011-12-06 11:06:54 +0900228}
229
Sean Paulbb7704d2014-01-30 16:19:06 -0500230static void fimd_apply(struct exynos_drm_manager *mgr)
Inki Daeec05da92011-12-06 11:06:54 +0900231{
Sean Paulbb7704d2014-01-30 16:19:06 -0500232 struct fimd_context *ctx = mgr->ctx;
Inki Daeec05da92011-12-06 11:06:54 +0900233 struct exynos_drm_manager_ops *mgr_ops = mgr->ops;
Inki Daeec05da92011-12-06 11:06:54 +0900234 struct fimd_win_data *win_data;
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900235 int i;
Inki Daeec05da92011-12-06 11:06:54 +0900236
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900237 for (i = 0; i < WINDOWS_NR; i++) {
238 win_data = &ctx->win_data[i];
Sean Paul1c6244c2014-01-30 16:19:02 -0500239 if (win_data->enabled && (mgr_ops && mgr_ops->win_commit))
Sean Paulbb7704d2014-01-30 16:19:06 -0500240 mgr_ops->win_commit(mgr, i);
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900241 }
Inki Daeec05da92011-12-06 11:06:54 +0900242
243 if (mgr_ops && mgr_ops->commit)
Sean Paulbb7704d2014-01-30 16:19:06 -0500244 mgr_ops->commit(mgr);
Inki Daeec05da92011-12-06 11:06:54 +0900245}
246
Sean Paulbb7704d2014-01-30 16:19:06 -0500247static void fimd_commit(struct exynos_drm_manager *mgr)
Inki Dae1c248b72011-10-04 19:19:01 +0900248{
Sean Paulbb7704d2014-01-30 16:19:06 -0500249 struct fimd_context *ctx = mgr->ctx;
Andrzej Hajda562ad9f2013-08-21 16:22:03 +0200250 struct exynos_drm_panel_info *panel = &ctx->panel;
Andrzej Hajda111e6052013-08-21 16:22:01 +0200251 struct videomode *vm = &panel->vm;
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +0530252 struct fimd_driver_data *driver_data;
Inki Dae1c248b72011-10-04 19:19:01 +0900253 u32 val;
254
Tomasz Figa18873462013-05-01 21:02:26 +0200255 driver_data = ctx->driver_data;
Inki Daee30d4bc2011-12-12 16:35:20 +0900256 if (ctx->suspended)
257 return;
258
Inki Dae1c248b72011-10-04 19:19:01 +0900259 /* setup polarity values from machine code. */
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +0530260 writel(ctx->vidcon1, ctx->regs + driver_data->timing_base + VIDCON1);
Inki Dae1c248b72011-10-04 19:19:01 +0900261
262 /* setup vertical timing values. */
Andrzej Hajda111e6052013-08-21 16:22:01 +0200263 val = VIDTCON0_VBPD(vm->vback_porch - 1) |
264 VIDTCON0_VFPD(vm->vfront_porch - 1) |
265 VIDTCON0_VSPW(vm->vsync_len - 1);
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +0530266 writel(val, ctx->regs + driver_data->timing_base + VIDTCON0);
Inki Dae1c248b72011-10-04 19:19:01 +0900267
268 /* setup horizontal timing values. */
Andrzej Hajda111e6052013-08-21 16:22:01 +0200269 val = VIDTCON1_HBPD(vm->hback_porch - 1) |
270 VIDTCON1_HFPD(vm->hfront_porch - 1) |
271 VIDTCON1_HSPW(vm->hsync_len - 1);
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +0530272 writel(val, ctx->regs + driver_data->timing_base + VIDTCON1);
Inki Dae1c248b72011-10-04 19:19:01 +0900273
274 /* setup horizontal and vertical display size. */
Andrzej Hajda111e6052013-08-21 16:22:01 +0200275 val = VIDTCON2_LINEVAL(vm->vactive - 1) |
276 VIDTCON2_HOZVAL(vm->hactive - 1) |
277 VIDTCON2_LINEVAL_E(vm->vactive - 1) |
278 VIDTCON2_HOZVAL_E(vm->hactive - 1);
Leela Krishna Amudalae2e13382012-09-21 16:52:15 +0530279 writel(val, ctx->regs + driver_data->timing_base + VIDTCON2);
Inki Dae1c248b72011-10-04 19:19:01 +0900280
281 /* setup clock source, clock divider, enable dma. */
282 val = ctx->vidcon0;
283 val &= ~(VIDCON0_CLKVAL_F_MASK | VIDCON0_CLKDIR);
284
Tomasz Figa411d9ed2013-05-01 21:02:28 +0200285 if (ctx->driver_data->has_clksel) {
286 val &= ~VIDCON0_CLKSEL_MASK;
287 val |= VIDCON0_CLKSEL_LCD;
288 }
289
Inki Dae1c248b72011-10-04 19:19:01 +0900290 if (ctx->clkdiv > 1)
291 val |= VIDCON0_CLKVAL_F(ctx->clkdiv - 1) | VIDCON0_CLKDIR;
292 else
293 val &= ~VIDCON0_CLKDIR; /* 1:1 clock */
294
295 /*
296 * fields of register with prefix '_F' would be updated
297 * at vsync(same as dma start)
298 */
299 val |= VIDCON0_ENVID | VIDCON0_ENVID_F;
300 writel(val, ctx->regs + VIDCON0);
301}
302
Sean Paulbb7704d2014-01-30 16:19:06 -0500303static int fimd_enable_vblank(struct exynos_drm_manager *mgr)
Inki Dae1c248b72011-10-04 19:19:01 +0900304{
Sean Paulbb7704d2014-01-30 16:19:06 -0500305 struct fimd_context *ctx = mgr->ctx;
Inki Dae1c248b72011-10-04 19:19:01 +0900306 u32 val;
307
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +0900308 if (ctx->suspended)
309 return -EPERM;
310
Inki Dae1c248b72011-10-04 19:19:01 +0900311 if (!test_and_set_bit(0, &ctx->irq_flags)) {
312 val = readl(ctx->regs + VIDINTCON0);
313
314 val |= VIDINTCON0_INT_ENABLE;
315 val |= VIDINTCON0_INT_FRAME;
316
317 val &= ~VIDINTCON0_FRAMESEL0_MASK;
318 val |= VIDINTCON0_FRAMESEL0_VSYNC;
319 val &= ~VIDINTCON0_FRAMESEL1_MASK;
320 val |= VIDINTCON0_FRAMESEL1_NONE;
321
322 writel(val, ctx->regs + VIDINTCON0);
323 }
324
325 return 0;
326}
327
Sean Paulbb7704d2014-01-30 16:19:06 -0500328static void fimd_disable_vblank(struct exynos_drm_manager *mgr)
Inki Dae1c248b72011-10-04 19:19:01 +0900329{
Sean Paulbb7704d2014-01-30 16:19:06 -0500330 struct fimd_context *ctx = mgr->ctx;
Inki Dae1c248b72011-10-04 19:19:01 +0900331 u32 val;
332
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +0900333 if (ctx->suspended)
334 return;
335
Inki Dae1c248b72011-10-04 19:19:01 +0900336 if (test_and_clear_bit(0, &ctx->irq_flags)) {
337 val = readl(ctx->regs + VIDINTCON0);
338
339 val &= ~VIDINTCON0_INT_FRAME;
340 val &= ~VIDINTCON0_INT_ENABLE;
341
342 writel(val, ctx->regs + VIDINTCON0);
343 }
344}
345
Sean Paulbb7704d2014-01-30 16:19:06 -0500346static void fimd_wait_for_vblank(struct exynos_drm_manager *mgr)
Prathyush K07033972012-12-06 20:16:02 +0530347{
Sean Paulbb7704d2014-01-30 16:19:06 -0500348 struct fimd_context *ctx = mgr->ctx;
Prathyush K07033972012-12-06 20:16:02 +0530349
Prathyush K01ce1132012-12-06 20:16:04 +0530350 if (ctx->suspended)
351 return;
352
353 atomic_set(&ctx->wait_vsync_event, 1);
354
355 /*
356 * wait for FIMD to signal VSYNC interrupt or return after
357 * timeout which is set to 50ms (refresh rate of 20).
358 */
359 if (!wait_event_timeout(ctx->wait_vsync_queue,
360 !atomic_read(&ctx->wait_vsync_event),
Seung-Woo Kim8dd9ad52013-12-30 16:01:29 +0900361 HZ/20))
Prathyush K07033972012-12-06 20:16:02 +0530362 DRM_DEBUG_KMS("vblank wait timed out.\n");
363}
364
Sean Paulbb7704d2014-01-30 16:19:06 -0500365static void fimd_win_mode_set(struct exynos_drm_manager *mgr,
366 struct exynos_drm_overlay *overlay)
Inki Dae1c248b72011-10-04 19:19:01 +0900367{
Sean Paulbb7704d2014-01-30 16:19:06 -0500368 struct fimd_context *ctx = mgr->ctx;
Inki Dae1c248b72011-10-04 19:19:01 +0900369 struct fimd_win_data *win_data;
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900370 int win;
Inki Dae19c8b832011-10-14 13:29:46 +0900371 unsigned long offset;
Inki Dae1c248b72011-10-04 19:19:01 +0900372
Inki Dae1c248b72011-10-04 19:19:01 +0900373 if (!overlay) {
Sean Paulbb7704d2014-01-30 16:19:06 -0500374 DRM_ERROR("overlay is NULL\n");
Inki Dae1c248b72011-10-04 19:19:01 +0900375 return;
376 }
377
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900378 win = overlay->zpos;
379 if (win == DEFAULT_ZPOS)
380 win = ctx->default_win;
381
Krzysztof Kozlowski37b006e2013-05-27 11:56:26 +0200382 if (win < 0 || win >= WINDOWS_NR)
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900383 return;
384
Inki Dae19c8b832011-10-14 13:29:46 +0900385 offset = overlay->fb_x * (overlay->bpp >> 3);
386 offset += overlay->fb_y * overlay->pitch;
387
388 DRM_DEBUG_KMS("offset = 0x%lx, pitch = %x\n", offset, overlay->pitch);
389
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900390 win_data = &ctx->win_data[win];
Inki Dae1c248b72011-10-04 19:19:01 +0900391
Inki Dae19c8b832011-10-14 13:29:46 +0900392 win_data->offset_x = overlay->crtc_x;
393 win_data->offset_y = overlay->crtc_y;
394 win_data->ovl_width = overlay->crtc_width;
395 win_data->ovl_height = overlay->crtc_height;
396 win_data->fb_width = overlay->fb_width;
397 win_data->fb_height = overlay->fb_height;
Seung-Woo Kim229d3532011-12-15 14:36:22 +0900398 win_data->dma_addr = overlay->dma_addr[0] + offset;
Inki Dae1c248b72011-10-04 19:19:01 +0900399 win_data->bpp = overlay->bpp;
Inki Daea4f38a82013-08-20 13:51:02 +0900400 win_data->pixel_format = overlay->pixel_format;
Inki Dae19c8b832011-10-14 13:29:46 +0900401 win_data->buf_offsize = (overlay->fb_width - overlay->crtc_width) *
402 (overlay->bpp >> 3);
403 win_data->line_size = overlay->crtc_width * (overlay->bpp >> 3);
404
405 DRM_DEBUG_KMS("offset_x = %d, offset_y = %d\n",
406 win_data->offset_x, win_data->offset_y);
407 DRM_DEBUG_KMS("ovl_width = %d, ovl_height = %d\n",
408 win_data->ovl_width, win_data->ovl_height);
YoungJun Choddd8e952012-12-10 15:44:58 +0900409 DRM_DEBUG_KMS("paddr = 0x%lx\n", (unsigned long)win_data->dma_addr);
Inki Dae19c8b832011-10-14 13:29:46 +0900410 DRM_DEBUG_KMS("fb_width = %d, crtc_width = %d\n",
411 overlay->fb_width, overlay->crtc_width);
Inki Dae1c248b72011-10-04 19:19:01 +0900412}
413
Sean Paulbb7704d2014-01-30 16:19:06 -0500414static void fimd_win_set_pixfmt(struct fimd_context *ctx, unsigned int win)
Inki Dae1c248b72011-10-04 19:19:01 +0900415{
Inki Dae1c248b72011-10-04 19:19:01 +0900416 struct fimd_win_data *win_data = &ctx->win_data[win];
417 unsigned long val;
418
Inki Dae1c248b72011-10-04 19:19:01 +0900419 val = WINCONx_ENWIN;
420
Inki Dae5cc46212013-08-20 14:28:56 +0900421 /*
422 * In case of s3c64xx, window 0 doesn't support alpha channel.
423 * So the request format is ARGB8888 then change it to XRGB8888.
424 */
425 if (ctx->driver_data->has_limited_fmt && !win) {
426 if (win_data->pixel_format == DRM_FORMAT_ARGB8888)
427 win_data->pixel_format = DRM_FORMAT_XRGB8888;
428 }
429
Inki Daea4f38a82013-08-20 13:51:02 +0900430 switch (win_data->pixel_format) {
431 case DRM_FORMAT_C8:
Inki Dae1c248b72011-10-04 19:19:01 +0900432 val |= WINCON0_BPPMODE_8BPP_PALETTE;
433 val |= WINCONx_BURSTLEN_8WORD;
434 val |= WINCONx_BYTSWP;
435 break;
Inki Daea4f38a82013-08-20 13:51:02 +0900436 case DRM_FORMAT_XRGB1555:
437 val |= WINCON0_BPPMODE_16BPP_1555;
438 val |= WINCONx_HAWSWP;
439 val |= WINCONx_BURSTLEN_16WORD;
440 break;
441 case DRM_FORMAT_RGB565:
Inki Dae1c248b72011-10-04 19:19:01 +0900442 val |= WINCON0_BPPMODE_16BPP_565;
443 val |= WINCONx_HAWSWP;
444 val |= WINCONx_BURSTLEN_16WORD;
445 break;
Inki Daea4f38a82013-08-20 13:51:02 +0900446 case DRM_FORMAT_XRGB8888:
Inki Dae1c248b72011-10-04 19:19:01 +0900447 val |= WINCON0_BPPMODE_24BPP_888;
448 val |= WINCONx_WSWP;
449 val |= WINCONx_BURSTLEN_16WORD;
450 break;
Inki Daea4f38a82013-08-20 13:51:02 +0900451 case DRM_FORMAT_ARGB8888:
452 val |= WINCON1_BPPMODE_25BPP_A1888
Inki Dae1c248b72011-10-04 19:19:01 +0900453 | WINCON1_BLD_PIX | WINCON1_ALPHA_SEL;
454 val |= WINCONx_WSWP;
455 val |= WINCONx_BURSTLEN_16WORD;
456 break;
457 default:
458 DRM_DEBUG_KMS("invalid pixel size so using unpacked 24bpp.\n");
459
460 val |= WINCON0_BPPMODE_24BPP_888;
461 val |= WINCONx_WSWP;
462 val |= WINCONx_BURSTLEN_16WORD;
463 break;
464 }
465
466 DRM_DEBUG_KMS("bpp = %d\n", win_data->bpp);
467
468 writel(val, ctx->regs + WINCON(win));
469}
470
Sean Paulbb7704d2014-01-30 16:19:06 -0500471static void fimd_win_set_colkey(struct fimd_context *ctx, unsigned int win)
Inki Dae1c248b72011-10-04 19:19:01 +0900472{
Inki Dae1c248b72011-10-04 19:19:01 +0900473 unsigned int keycon0 = 0, keycon1 = 0;
474
Inki Dae1c248b72011-10-04 19:19:01 +0900475 keycon0 = ~(WxKEYCON0_KEYBL_EN | WxKEYCON0_KEYEN_F |
476 WxKEYCON0_DIRCON) | WxKEYCON0_COMPKEY(0);
477
478 keycon1 = WxKEYCON1_COLVAL(0xffffffff);
479
480 writel(keycon0, ctx->regs + WKEYCON0_BASE(win));
481 writel(keycon1, ctx->regs + WKEYCON1_BASE(win));
482}
483
Tomasz Figade7af102013-05-01 21:02:27 +0200484/**
485 * shadow_protect_win() - disable updating values from shadow registers at vsync
486 *
487 * @win: window to protect registers for
488 * @protect: 1 to protect (disable updates)
489 */
490static void fimd_shadow_protect_win(struct fimd_context *ctx,
491 int win, bool protect)
492{
493 u32 reg, bits, val;
494
495 if (ctx->driver_data->has_shadowcon) {
496 reg = SHADOWCON;
497 bits = SHADOWCON_WINx_PROTECT(win);
498 } else {
499 reg = PRTCON;
500 bits = PRTCON_PROTECT;
501 }
502
503 val = readl(ctx->regs + reg);
504 if (protect)
505 val |= bits;
506 else
507 val &= ~bits;
508 writel(val, ctx->regs + reg);
509}
510
Sean Paulbb7704d2014-01-30 16:19:06 -0500511static void fimd_win_commit(struct exynos_drm_manager *mgr, int zpos)
Inki Dae1c248b72011-10-04 19:19:01 +0900512{
Sean Paulbb7704d2014-01-30 16:19:06 -0500513 struct fimd_context *ctx = mgr->ctx;
Inki Dae1c248b72011-10-04 19:19:01 +0900514 struct fimd_win_data *win_data;
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900515 int win = zpos;
Inki Dae1c248b72011-10-04 19:19:01 +0900516 unsigned long val, alpha, size;
Joonyoung Shimf56aad32012-12-14 15:48:23 +0900517 unsigned int last_x;
518 unsigned int last_y;
Inki Dae1c248b72011-10-04 19:19:01 +0900519
Inki Daee30d4bc2011-12-12 16:35:20 +0900520 if (ctx->suspended)
521 return;
522
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900523 if (win == DEFAULT_ZPOS)
524 win = ctx->default_win;
525
Krzysztof Kozlowski37b006e2013-05-27 11:56:26 +0200526 if (win < 0 || win >= WINDOWS_NR)
Inki Dae1c248b72011-10-04 19:19:01 +0900527 return;
528
529 win_data = &ctx->win_data[win];
530
531 /*
Tomasz Figade7af102013-05-01 21:02:27 +0200532 * SHADOWCON/PRTCON register is used for enabling timing.
Inki Dae1c248b72011-10-04 19:19:01 +0900533 *
534 * for example, once only width value of a register is set,
535 * if the dma is started then fimd hardware could malfunction so
536 * with protect window setting, the register fields with prefix '_F'
537 * wouldn't be updated at vsync also but updated once unprotect window
538 * is set.
539 */
540
541 /* protect windows */
Tomasz Figade7af102013-05-01 21:02:27 +0200542 fimd_shadow_protect_win(ctx, win, true);
Inki Dae1c248b72011-10-04 19:19:01 +0900543
544 /* buffer start address */
Inki Dae2c871122011-11-12 15:23:32 +0900545 val = (unsigned long)win_data->dma_addr;
Inki Dae1c248b72011-10-04 19:19:01 +0900546 writel(val, ctx->regs + VIDWx_BUF_START(win, 0));
547
548 /* buffer end address */
Inki Dae19c8b832011-10-14 13:29:46 +0900549 size = win_data->fb_width * win_data->ovl_height * (win_data->bpp >> 3);
Inki Dae2c871122011-11-12 15:23:32 +0900550 val = (unsigned long)(win_data->dma_addr + size);
Inki Dae1c248b72011-10-04 19:19:01 +0900551 writel(val, ctx->regs + VIDWx_BUF_END(win, 0));
552
553 DRM_DEBUG_KMS("start addr = 0x%lx, end addr = 0x%lx, size = 0x%lx\n",
Inki Dae2c871122011-11-12 15:23:32 +0900554 (unsigned long)win_data->dma_addr, val, size);
Inki Dae19c8b832011-10-14 13:29:46 +0900555 DRM_DEBUG_KMS("ovl_width = %d, ovl_height = %d\n",
556 win_data->ovl_width, win_data->ovl_height);
Inki Dae1c248b72011-10-04 19:19:01 +0900557
558 /* buffer size */
559 val = VIDW_BUF_SIZE_OFFSET(win_data->buf_offsize) |
Joonyoung Shimca555e52012-12-14 15:48:24 +0900560 VIDW_BUF_SIZE_PAGEWIDTH(win_data->line_size) |
561 VIDW_BUF_SIZE_OFFSET_E(win_data->buf_offsize) |
562 VIDW_BUF_SIZE_PAGEWIDTH_E(win_data->line_size);
Inki Dae1c248b72011-10-04 19:19:01 +0900563 writel(val, ctx->regs + VIDWx_BUF_SIZE(win, 0));
564
565 /* OSD position */
566 val = VIDOSDxA_TOPLEFT_X(win_data->offset_x) |
Joonyoung Shimca555e52012-12-14 15:48:24 +0900567 VIDOSDxA_TOPLEFT_Y(win_data->offset_y) |
568 VIDOSDxA_TOPLEFT_X_E(win_data->offset_x) |
569 VIDOSDxA_TOPLEFT_Y_E(win_data->offset_y);
Inki Dae1c248b72011-10-04 19:19:01 +0900570 writel(val, ctx->regs + VIDOSD_A(win));
571
Joonyoung Shimf56aad32012-12-14 15:48:23 +0900572 last_x = win_data->offset_x + win_data->ovl_width;
573 if (last_x)
574 last_x--;
575 last_y = win_data->offset_y + win_data->ovl_height;
576 if (last_y)
577 last_y--;
578
Joonyoung Shimca555e52012-12-14 15:48:24 +0900579 val = VIDOSDxB_BOTRIGHT_X(last_x) | VIDOSDxB_BOTRIGHT_Y(last_y) |
580 VIDOSDxB_BOTRIGHT_X_E(last_x) | VIDOSDxB_BOTRIGHT_Y_E(last_y);
581
Inki Dae1c248b72011-10-04 19:19:01 +0900582 writel(val, ctx->regs + VIDOSD_B(win));
583
Inki Dae19c8b832011-10-14 13:29:46 +0900584 DRM_DEBUG_KMS("osd pos: tx = %d, ty = %d, bx = %d, by = %d\n",
Joonyoung Shimf56aad32012-12-14 15:48:23 +0900585 win_data->offset_x, win_data->offset_y, last_x, last_y);
Inki Dae1c248b72011-10-04 19:19:01 +0900586
587 /* hardware window 0 doesn't support alpha channel. */
588 if (win != 0) {
589 /* OSD alpha */
590 alpha = VIDISD14C_ALPHA1_R(0xf) |
591 VIDISD14C_ALPHA1_G(0xf) |
592 VIDISD14C_ALPHA1_B(0xf);
593
594 writel(alpha, ctx->regs + VIDOSD_C(win));
595 }
596
597 /* OSD size */
598 if (win != 3 && win != 4) {
599 u32 offset = VIDOSD_D(win);
600 if (win == 0)
Leela Krishna Amudala0f10cf12013-03-07 23:28:52 -0500601 offset = VIDOSD_C(win);
Inki Dae19c8b832011-10-14 13:29:46 +0900602 val = win_data->ovl_width * win_data->ovl_height;
Inki Dae1c248b72011-10-04 19:19:01 +0900603 writel(val, ctx->regs + offset);
604
605 DRM_DEBUG_KMS("osd size = 0x%x\n", (unsigned int)val);
606 }
607
Sean Paulbb7704d2014-01-30 16:19:06 -0500608 fimd_win_set_pixfmt(ctx, win);
Inki Dae1c248b72011-10-04 19:19:01 +0900609
610 /* hardware window 0 doesn't support color key. */
611 if (win != 0)
Sean Paulbb7704d2014-01-30 16:19:06 -0500612 fimd_win_set_colkey(ctx, win);
Inki Dae1c248b72011-10-04 19:19:01 +0900613
Inki Daeec05da92011-12-06 11:06:54 +0900614 /* wincon */
615 val = readl(ctx->regs + WINCON(win));
616 val |= WINCONx_ENWIN;
617 writel(val, ctx->regs + WINCON(win));
618
Inki Dae1c248b72011-10-04 19:19:01 +0900619 /* Enable DMA channel and unprotect windows */
Tomasz Figade7af102013-05-01 21:02:27 +0200620 fimd_shadow_protect_win(ctx, win, false);
621
622 if (ctx->driver_data->has_shadowcon) {
623 val = readl(ctx->regs + SHADOWCON);
624 val |= SHADOWCON_CHx_ENABLE(win);
625 writel(val, ctx->regs + SHADOWCON);
626 }
Inki Daeec05da92011-12-06 11:06:54 +0900627
628 win_data->enabled = true;
Inki Dae1c248b72011-10-04 19:19:01 +0900629}
630
Sean Paulbb7704d2014-01-30 16:19:06 -0500631static void fimd_win_disable(struct exynos_drm_manager *mgr, int zpos)
Inki Dae1c248b72011-10-04 19:19:01 +0900632{
Sean Paulbb7704d2014-01-30 16:19:06 -0500633 struct fimd_context *ctx = mgr->ctx;
Inki Daeec05da92011-12-06 11:06:54 +0900634 struct fimd_win_data *win_data;
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900635 int win = zpos;
Inki Dae1c248b72011-10-04 19:19:01 +0900636 u32 val;
637
Joonyoung Shim864ee9e2011-12-08 17:54:07 +0900638 if (win == DEFAULT_ZPOS)
639 win = ctx->default_win;
640
Krzysztof Kozlowski37b006e2013-05-27 11:56:26 +0200641 if (win < 0 || win >= WINDOWS_NR)
Inki Dae1c248b72011-10-04 19:19:01 +0900642 return;
643
Inki Daeec05da92011-12-06 11:06:54 +0900644 win_data = &ctx->win_data[win];
645
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530646 if (ctx->suspended) {
647 /* do not resume this window*/
648 win_data->resume = false;
649 return;
650 }
651
Inki Dae1c248b72011-10-04 19:19:01 +0900652 /* protect windows */
Tomasz Figade7af102013-05-01 21:02:27 +0200653 fimd_shadow_protect_win(ctx, win, true);
Inki Dae1c248b72011-10-04 19:19:01 +0900654
655 /* wincon */
656 val = readl(ctx->regs + WINCON(win));
657 val &= ~WINCONx_ENWIN;
658 writel(val, ctx->regs + WINCON(win));
659
660 /* unprotect windows */
Tomasz Figade7af102013-05-01 21:02:27 +0200661 if (ctx->driver_data->has_shadowcon) {
662 val = readl(ctx->regs + SHADOWCON);
663 val &= ~SHADOWCON_CHx_ENABLE(win);
664 writel(val, ctx->regs + SHADOWCON);
665 }
666
667 fimd_shadow_protect_win(ctx, win, false);
Inki Daeec05da92011-12-06 11:06:54 +0900668
669 win_data->enabled = false;
Inki Dae1c248b72011-10-04 19:19:01 +0900670}
671
Sean Paul1c6244c2014-01-30 16:19:02 -0500672static struct exynos_drm_manager_ops fimd_manager_ops = {
Sean Paul40c8ab42014-01-30 16:19:04 -0500673 .initialize = fimd_mgr_initialize,
Sean Paul1c6244c2014-01-30 16:19:02 -0500674 .dpms = fimd_dpms,
675 .apply = fimd_apply,
676 .commit = fimd_commit,
677 .enable_vblank = fimd_enable_vblank,
678 .disable_vblank = fimd_disable_vblank,
679 .wait_for_vblank = fimd_wait_for_vblank,
680 .win_mode_set = fimd_win_mode_set,
681 .win_commit = fimd_win_commit,
682 .win_disable = fimd_win_disable,
Inki Dae1c248b72011-10-04 19:19:01 +0900683};
684
Joonyoung Shim677e84c2012-04-05 20:49:27 +0900685static struct exynos_drm_manager fimd_manager = {
686 .pipe = -1,
687 .ops = &fimd_manager_ops,
Joonyoung Shim677e84c2012-04-05 20:49:27 +0900688 .display_ops = &fimd_display_ops,
689};
690
Inki Dae1c248b72011-10-04 19:19:01 +0900691static irqreturn_t fimd_irq_handler(int irq, void *dev_id)
692{
693 struct fimd_context *ctx = (struct fimd_context *)dev_id;
694 struct exynos_drm_subdrv *subdrv = &ctx->subdrv;
Joonyoung Shim677e84c2012-04-05 20:49:27 +0900695 struct exynos_drm_manager *manager = subdrv->manager;
Inki Dae1c248b72011-10-04 19:19:01 +0900696 u32 val;
697
698 val = readl(ctx->regs + VIDINTCON1);
699
700 if (val & VIDINTCON1_INT_FRAME)
701 /* VSYNC interrupt */
702 writel(VIDINTCON1_INT_FRAME, ctx->regs + VIDINTCON1);
703
Inki Daeec05da92011-12-06 11:06:54 +0900704 /* check the crtc is detached already from encoder */
Sean Paul40c8ab42014-01-30 16:19:04 -0500705 if (manager->pipe < 0 || !ctx->drm_dev)
Inki Daeec05da92011-12-06 11:06:54 +0900706 goto out;
Inki Dae483b88f2011-11-11 21:28:00 +0900707
Sean Paul40c8ab42014-01-30 16:19:04 -0500708 drm_handle_vblank(ctx->drm_dev, manager->pipe);
709 exynos_drm_crtc_finish_pageflip(ctx->drm_dev, manager->pipe);
Inki Dae1c248b72011-10-04 19:19:01 +0900710
Prathyush K01ce1132012-12-06 20:16:04 +0530711 /* set wait vsync event to zero and wake up queue. */
712 if (atomic_read(&ctx->wait_vsync_event)) {
713 atomic_set(&ctx->wait_vsync_event, 0);
Seung-Woo Kim8dd9ad52013-12-30 16:01:29 +0900714 wake_up(&ctx->wait_vsync_queue);
Prathyush K01ce1132012-12-06 20:16:04 +0530715 }
Inki Daeec05da92011-12-06 11:06:54 +0900716out:
Inki Dae1c248b72011-10-04 19:19:01 +0900717 return IRQ_HANDLED;
718}
719
Inki Dae41c24342011-10-14 13:29:48 +0900720static int fimd_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
Inki Dae1c248b72011-10-04 19:19:01 +0900721{
Inki Dae1c248b72011-10-04 19:19:01 +0900722 /*
723 * enable drm irq mode.
Ville Syrjälä44238432013-10-04 14:53:37 +0300724 * - with irq_enabled = true, we can use the vblank feature.
Inki Dae1c248b72011-10-04 19:19:01 +0900725 *
726 * P.S. note that we wouldn't use drm irq handler but
727 * just specific driver own one instead because
728 * drm framework supports only one irq handler.
729 */
Ville Syrjälä44238432013-10-04 14:53:37 +0300730 drm_dev->irq_enabled = true;
Inki Dae1c248b72011-10-04 19:19:01 +0900731
Inki Daeec05da92011-12-06 11:06:54 +0900732 /*
Ville Syrjäläba0bf122013-10-04 14:53:33 +0300733 * with vblank_disable_allowed = true, vblank interrupt will be disabled
Inki Daeec05da92011-12-06 11:06:54 +0900734 * by drm timer once a current process gives up ownership of
735 * vblank event.(after drm_vblank_put function is called)
736 */
Ville Syrjäläba0bf122013-10-04 14:53:33 +0300737 drm_dev->vblank_disable_allowed = true;
Inki Daeec05da92011-12-06 11:06:54 +0900738
Inki Daebcc5cd12012-10-19 17:16:36 +0900739 /* attach this sub driver to iommu mapping if supported. */
740 if (is_drm_iommu_supported(drm_dev))
741 drm_iommu_attach_device(drm_dev, dev);
742
Inki Dae1c248b72011-10-04 19:19:01 +0900743 return 0;
744}
745
Inki Dae29cb6022012-09-05 14:12:06 +0900746static void fimd_subdrv_remove(struct drm_device *drm_dev, struct device *dev)
Inki Dae1c248b72011-10-04 19:19:01 +0900747{
Inki Daebcc5cd12012-10-19 17:16:36 +0900748 /* detach this sub driver from iommu mapping if supported. */
749 if (is_drm_iommu_supported(drm_dev))
750 drm_iommu_detach_device(drm_dev, dev);
Inki Dae1c248b72011-10-04 19:19:01 +0900751}
752
Andrzej Hajda111e6052013-08-21 16:22:01 +0200753static int fimd_configure_clocks(struct fimd_context *ctx, struct device *dev)
Inki Dae1c248b72011-10-04 19:19:01 +0900754{
Andrzej Hajda562ad9f2013-08-21 16:22:03 +0200755 struct videomode *vm = &ctx->panel.vm;
Andrzej Hajda111e6052013-08-21 16:22:01 +0200756 unsigned long clk;
Inki Dae1c248b72011-10-04 19:19:01 +0900757
Andrzej Hajda111e6052013-08-21 16:22:01 +0200758 ctx->bus_clk = devm_clk_get(dev, "fimd");
759 if (IS_ERR(ctx->bus_clk)) {
760 dev_err(dev, "failed to get bus clock\n");
761 return PTR_ERR(ctx->bus_clk);
Inki Dae1c248b72011-10-04 19:19:01 +0900762 }
763
Andrzej Hajda111e6052013-08-21 16:22:01 +0200764 ctx->lcd_clk = devm_clk_get(dev, "sclk_fimd");
765 if (IS_ERR(ctx->lcd_clk)) {
766 dev_err(dev, "failed to get lcd clock\n");
767 return PTR_ERR(ctx->lcd_clk);
768 }
769
770 clk = clk_get_rate(ctx->lcd_clk);
771 if (clk == 0) {
772 dev_err(dev, "error getting sclk_fimd clock rate\n");
773 return -EINVAL;
774 }
775
776 if (vm->pixelclock == 0) {
777 unsigned long c;
778 c = vm->hactive + vm->hback_porch + vm->hfront_porch +
779 vm->hsync_len;
780 c *= vm->vactive + vm->vback_porch + vm->vfront_porch +
781 vm->vsync_len;
782 vm->pixelclock = c * FIMD_DEFAULT_FRAMERATE;
783 if (vm->pixelclock == 0) {
784 dev_err(dev, "incorrect display timings\n");
785 return -EINVAL;
786 }
787 dev_warn(dev, "pixel clock recalculated to %luHz (%dHz frame rate)\n",
788 vm->pixelclock, FIMD_DEFAULT_FRAMERATE);
789 }
790 ctx->clkdiv = DIV_ROUND_UP(clk, vm->pixelclock);
791 if (ctx->clkdiv > 256) {
792 dev_warn(dev, "calculated pixel clock divider too high (%u), lowered to 256\n",
793 ctx->clkdiv);
794 ctx->clkdiv = 256;
795 }
796 vm->pixelclock = clk / ctx->clkdiv;
797 DRM_DEBUG_KMS("pixel clock = %lu, clkdiv = %d\n", vm->pixelclock,
798 ctx->clkdiv);
799
800 return 0;
Inki Dae1c248b72011-10-04 19:19:01 +0900801}
802
803static void fimd_clear_win(struct fimd_context *ctx, int win)
804{
Inki Dae1c248b72011-10-04 19:19:01 +0900805 writel(0, ctx->regs + WINCON(win));
806 writel(0, ctx->regs + VIDOSD_A(win));
807 writel(0, ctx->regs + VIDOSD_B(win));
808 writel(0, ctx->regs + VIDOSD_C(win));
809
810 if (win == 1 || win == 2)
811 writel(0, ctx->regs + VIDOSD_D(win));
812
Tomasz Figade7af102013-05-01 21:02:27 +0200813 fimd_shadow_protect_win(ctx, win, false);
Inki Dae1c248b72011-10-04 19:19:01 +0900814}
815
Inki Dae5d553932012-08-17 17:08:04 +0900816static int fimd_clock(struct fimd_context *ctx, bool enable)
Inki Dae373af0c2012-01-27 11:54:58 +0900817{
Inki Dae373af0c2012-01-27 11:54:58 +0900818 if (enable) {
819 int ret;
820
Vikas Sajjan11963a62013-04-23 17:19:50 +0530821 ret = clk_prepare_enable(ctx->bus_clk);
Inki Dae373af0c2012-01-27 11:54:58 +0900822 if (ret < 0)
823 return ret;
824
Vikas Sajjan11963a62013-04-23 17:19:50 +0530825 ret = clk_prepare_enable(ctx->lcd_clk);
Inki Dae373af0c2012-01-27 11:54:58 +0900826 if (ret < 0) {
Vikas Sajjan11963a62013-04-23 17:19:50 +0530827 clk_disable_unprepare(ctx->bus_clk);
Inki Dae373af0c2012-01-27 11:54:58 +0900828 return ret;
829 }
Inki Dae5d553932012-08-17 17:08:04 +0900830 } else {
Vikas Sajjan11963a62013-04-23 17:19:50 +0530831 clk_disable_unprepare(ctx->lcd_clk);
832 clk_disable_unprepare(ctx->bus_clk);
Inki Dae5d553932012-08-17 17:08:04 +0900833 }
834
835 return 0;
836}
837
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530838static void fimd_window_suspend(struct device *dev)
839{
Sean Paulbb7704d2014-01-30 16:19:06 -0500840 struct exynos_drm_manager *mgr = get_fimd_manager(dev);
841 struct fimd_context *ctx = mgr->ctx;
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530842 struct fimd_win_data *win_data;
843 int i;
844
845 for (i = 0; i < WINDOWS_NR; i++) {
846 win_data = &ctx->win_data[i];
847 win_data->resume = win_data->enabled;
Sean Paulbb7704d2014-01-30 16:19:06 -0500848 fimd_win_disable(mgr, i);
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530849 }
Sean Paulbb7704d2014-01-30 16:19:06 -0500850 fimd_wait_for_vblank(mgr);
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530851}
852
853static void fimd_window_resume(struct device *dev)
854{
Sean Paulbb7704d2014-01-30 16:19:06 -0500855 struct exynos_drm_manager *mgr = get_fimd_manager(dev);
856 struct fimd_context *ctx = mgr->ctx;
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530857 struct fimd_win_data *win_data;
858 int i;
859
860 for (i = 0; i < WINDOWS_NR; i++) {
861 win_data = &ctx->win_data[i];
862 win_data->enabled = win_data->resume;
863 win_data->resume = false;
864 }
865}
866
Sean Paulbb7704d2014-01-30 16:19:06 -0500867static int fimd_activate(struct exynos_drm_manager *mgr, bool enable)
Inki Dae5d553932012-08-17 17:08:04 +0900868{
Sean Paulbb7704d2014-01-30 16:19:06 -0500869 struct fimd_context *ctx = mgr->ctx;
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530870 struct device *dev = ctx->subdrv.dev;
Sean Paulbb7704d2014-01-30 16:19:06 -0500871
Inki Dae5d553932012-08-17 17:08:04 +0900872 if (enable) {
873 int ret;
Inki Dae5d553932012-08-17 17:08:04 +0900874
875 ret = fimd_clock(ctx, true);
876 if (ret < 0)
877 return ret;
Inki Dae373af0c2012-01-27 11:54:58 +0900878
879 ctx->suspended = false;
880
881 /* if vblank was enabled status, enable it again. */
882 if (test_and_clear_bit(0, &ctx->irq_flags))
Sean Paulbb7704d2014-01-30 16:19:06 -0500883 fimd_enable_vblank(mgr);
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530884
885 fimd_window_resume(dev);
Inki Dae373af0c2012-01-27 11:54:58 +0900886 } else {
Prathyush Kdb7e55a2012-12-06 20:16:06 +0530887 fimd_window_suspend(dev);
888
Inki Dae5d553932012-08-17 17:08:04 +0900889 fimd_clock(ctx, false);
Inki Dae373af0c2012-01-27 11:54:58 +0900890 ctx->suspended = true;
891 }
892
893 return 0;
894}
895
Andrzej Hajda562ad9f2013-08-21 16:22:03 +0200896static int fimd_get_platform_data(struct fimd_context *ctx, struct device *dev)
Inki Dae1c248b72011-10-04 19:19:01 +0900897{
Sachin Kamat2d3f1732013-08-28 10:47:58 +0530898 struct videomode *vm;
899 int ret;
Vikas Sajjan7f4596f2013-03-07 12:15:21 +0530900
Sachin Kamat2d3f1732013-08-28 10:47:58 +0530901 vm = &ctx->panel.vm;
902 ret = of_get_videomode(dev->of_node, vm, OF_USE_NATIVE_MODE);
903 if (ret) {
904 DRM_ERROR("failed: of_get_videomode() : %d\n", ret);
905 return ret;
Inki Dae1c248b72011-10-04 19:19:01 +0900906 }
907
Sachin Kamat2d3f1732013-08-28 10:47:58 +0530908 if (vm->flags & DISPLAY_FLAGS_VSYNC_LOW)
909 ctx->vidcon1 |= VIDCON1_INV_VSYNC;
910 if (vm->flags & DISPLAY_FLAGS_HSYNC_LOW)
911 ctx->vidcon1 |= VIDCON1_INV_HSYNC;
912 if (vm->flags & DISPLAY_FLAGS_DE_LOW)
913 ctx->vidcon1 |= VIDCON1_INV_VDEN;
914 if (vm->flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE)
915 ctx->vidcon1 |= VIDCON1_INV_VCLK;
916
Andrzej Hajda562ad9f2013-08-21 16:22:03 +0200917 return 0;
918}
919
920static int fimd_probe(struct platform_device *pdev)
921{
922 struct device *dev = &pdev->dev;
923 struct fimd_context *ctx;
924 struct exynos_drm_subdrv *subdrv;
925 struct resource *res;
926 int win;
927 int ret = -EINVAL;
Inki Dae1c248b72011-10-04 19:19:01 +0900928
Sachin Kamat2d3f1732013-08-28 10:47:58 +0530929 if (!dev->of_node)
930 return -ENODEV;
931
Seung-Woo Kimd873ab92013-05-22 21:14:14 +0900932 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
Inki Dae1c248b72011-10-04 19:19:01 +0900933 if (!ctx)
934 return -ENOMEM;
935
Sean Paulbb7704d2014-01-30 16:19:06 -0500936 ctx->dev = dev;
937
Andrzej Hajda562ad9f2013-08-21 16:22:03 +0200938 ret = fimd_get_platform_data(ctx, dev);
939 if (ret)
940 return ret;
941
Andrzej Hajda111e6052013-08-21 16:22:01 +0200942 ret = fimd_configure_clocks(ctx, dev);
943 if (ret)
944 return ret;
Inki Dae1c248b72011-10-04 19:19:01 +0900945
Inki Dae1c248b72011-10-04 19:19:01 +0900946 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
Inki Dae1c248b72011-10-04 19:19:01 +0900947
Seung-Woo Kimd873ab92013-05-22 21:14:14 +0900948 ctx->regs = devm_ioremap_resource(dev, res);
Thierry Redingd4ed6022013-01-21 11:09:02 +0100949 if (IS_ERR(ctx->regs))
950 return PTR_ERR(ctx->regs);
Inki Dae1c248b72011-10-04 19:19:01 +0900951
Vikas Sajjan1977e6d2013-04-02 17:53:01 +0900952 res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "vsync");
Inki Dae1c248b72011-10-04 19:19:01 +0900953 if (!res) {
954 dev_err(dev, "irq request failed.\n");
Sachin Kamata4d8de52012-11-26 09:47:14 +0530955 return -ENXIO;
Inki Dae1c248b72011-10-04 19:19:01 +0900956 }
957
958 ctx->irq = res->start;
959
Seung-Woo Kimd873ab92013-05-22 21:14:14 +0900960 ret = devm_request_irq(dev, ctx->irq, fimd_irq_handler,
Sachin Kamatedc57262012-06-19 11:47:39 +0530961 0, "drm_fimd", ctx);
962 if (ret) {
Inki Dae1c248b72011-10-04 19:19:01 +0900963 dev_err(dev, "irq request failed.\n");
Sachin Kamata4d8de52012-11-26 09:47:14 +0530964 return ret;
Inki Dae1c248b72011-10-04 19:19:01 +0900965 }
966
Tomasz Figa18873462013-05-01 21:02:26 +0200967 ctx->driver_data = drm_fimd_get_driver_data(pdev);
Daniel Vetter57ed0f72013-12-11 11:34:43 +0100968 init_waitqueue_head(&ctx->wait_vsync_queue);
Prathyush K01ce1132012-12-06 20:16:04 +0530969 atomic_set(&ctx->wait_vsync_event, 0);
Inki Dae1c248b72011-10-04 19:19:01 +0900970
Sean Paulbb7704d2014-01-30 16:19:06 -0500971 fimd_manager.ctx = ctx;
972
Inki Dae1c248b72011-10-04 19:19:01 +0900973 subdrv = &ctx->subdrv;
974
Joonyoung Shim677e84c2012-04-05 20:49:27 +0900975 subdrv->dev = dev;
976 subdrv->manager = &fimd_manager;
Inki Dae1c248b72011-10-04 19:19:01 +0900977 subdrv->probe = fimd_subdrv_probe;
978 subdrv->remove = fimd_subdrv_remove;
Inki Dae1c248b72011-10-04 19:19:01 +0900979
Inki Daec32b06e2011-12-16 21:49:03 +0900980 mutex_init(&ctx->lock);
981
Sean Paulbb7704d2014-01-30 16:19:06 -0500982 platform_set_drvdata(pdev, &fimd_manager);
Inki Daec32b06e2011-12-16 21:49:03 +0900983
Inki Daec32b06e2011-12-16 21:49:03 +0900984 pm_runtime_enable(dev);
985 pm_runtime_get_sync(dev);
986
987 for (win = 0; win < WINDOWS_NR; win++)
988 fimd_clear_win(ctx, win);
989
Inki Dae1c248b72011-10-04 19:19:01 +0900990 exynos_drm_subdrv_register(subdrv);
991
992 return 0;
Inki Dae1c248b72011-10-04 19:19:01 +0900993}
994
Greg Kroah-Hartman56550d92012-12-21 15:09:25 -0800995static int fimd_remove(struct platform_device *pdev)
Inki Dae1c248b72011-10-04 19:19:01 +0900996{
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +0900997 struct device *dev = &pdev->dev;
Sean Paulbb7704d2014-01-30 16:19:06 -0500998 struct exynos_drm_manager *mgr = platform_get_drvdata(pdev);
999 struct fimd_context *ctx = mgr->ctx;
Inki Dae1c248b72011-10-04 19:19:01 +09001000
Inki Dae1c248b72011-10-04 19:19:01 +09001001 exynos_drm_subdrv_unregister(&ctx->subdrv);
1002
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001003 if (ctx->suspended)
1004 goto out;
1005
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001006 pm_runtime_set_suspended(dev);
1007 pm_runtime_put_sync(dev);
1008
1009out:
1010 pm_runtime_disable(dev);
1011
Inki Dae1c248b72011-10-04 19:19:01 +09001012 return 0;
1013}
1014
Inki Daee30d4bc2011-12-12 16:35:20 +09001015#ifdef CONFIG_PM_SLEEP
1016static int fimd_suspend(struct device *dev)
1017{
Sean Paulbb7704d2014-01-30 16:19:06 -05001018 struct exynos_drm_manager *mgr = get_fimd_manager(dev);
Inki Daee30d4bc2011-12-12 16:35:20 +09001019
Inki Dae373af0c2012-01-27 11:54:58 +09001020 /*
1021 * do not use pm_runtime_suspend(). if pm_runtime_suspend() is
1022 * called here, an error would be returned by that interface
1023 * because the usage_count of pm runtime is more than 1.
1024 */
Inki Dae5d553932012-08-17 17:08:04 +09001025 if (!pm_runtime_suspended(dev))
Sean Paulbb7704d2014-01-30 16:19:06 -05001026 return fimd_activate(mgr, false);
Inki Dae5d553932012-08-17 17:08:04 +09001027
1028 return 0;
Inki Daee30d4bc2011-12-12 16:35:20 +09001029}
1030
1031static int fimd_resume(struct device *dev)
1032{
Sean Paulbb7704d2014-01-30 16:19:06 -05001033 struct exynos_drm_manager *mgr = get_fimd_manager(dev);
Inki Daee30d4bc2011-12-12 16:35:20 +09001034
Inki Dae373af0c2012-01-27 11:54:58 +09001035 /*
1036 * if entered to sleep when lcd panel was on, the usage_count
1037 * of pm runtime would still be 1 so in this case, fimd driver
1038 * should be on directly not drawing on pm runtime interface.
1039 */
Prathyush K28998af2012-12-27 06:40:13 -05001040 if (!pm_runtime_suspended(dev)) {
Inki Dae5d553932012-08-17 17:08:04 +09001041 int ret;
1042
Sean Paulbb7704d2014-01-30 16:19:06 -05001043 ret = fimd_activate(mgr, true);
Inki Dae5d553932012-08-17 17:08:04 +09001044 if (ret < 0)
1045 return ret;
1046
1047 /*
1048 * in case of dpms on(standby), fimd_apply function will
1049 * be called by encoder's dpms callback to update fimd's
1050 * registers but in case of sleep wakeup, it's not.
1051 * so fimd_apply function should be called at here.
1052 */
Sean Paulbb7704d2014-01-30 16:19:06 -05001053 fimd_apply(mgr);
Inki Dae5d553932012-08-17 17:08:04 +09001054 }
Inki Daee30d4bc2011-12-12 16:35:20 +09001055
Inki Daee30d4bc2011-12-12 16:35:20 +09001056 return 0;
1057}
1058#endif
1059
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001060#ifdef CONFIG_PM_RUNTIME
1061static int fimd_runtime_suspend(struct device *dev)
1062{
Sean Paulbb7704d2014-01-30 16:19:06 -05001063 struct exynos_drm_manager *mgr = get_fimd_manager(dev);
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001064
Sean Paulbb7704d2014-01-30 16:19:06 -05001065 return fimd_activate(mgr, false);
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001066}
1067
1068static int fimd_runtime_resume(struct device *dev)
1069{
Sean Paulbb7704d2014-01-30 16:19:06 -05001070 struct exynos_drm_manager *mgr = get_fimd_manager(dev);
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001071
Sean Paulbb7704d2014-01-30 16:19:06 -05001072 return fimd_activate(mgr, true);
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001073}
1074#endif
1075
1076static const struct dev_pm_ops fimd_pm_ops = {
Inki Daee30d4bc2011-12-12 16:35:20 +09001077 SET_SYSTEM_SLEEP_PM_OPS(fimd_suspend, fimd_resume)
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001078 SET_RUNTIME_PM_OPS(fimd_runtime_suspend, fimd_runtime_resume, NULL)
1079};
1080
Joonyoung Shim132a5b92012-03-16 18:47:08 +09001081struct platform_driver fimd_driver = {
Inki Dae1c248b72011-10-04 19:19:01 +09001082 .probe = fimd_probe,
Greg Kroah-Hartman56550d92012-12-21 15:09:25 -08001083 .remove = fimd_remove,
Inki Dae1c248b72011-10-04 19:19:01 +09001084 .driver = {
1085 .name = "exynos4-fb",
1086 .owner = THIS_MODULE,
Joonyoung Shimcb91f6a2011-12-09 16:52:11 +09001087 .pm = &fimd_pm_ops,
Sachin Kamat2d3f1732013-08-28 10:47:58 +05301088 .of_match_table = fimd_driver_dt_match,
Inki Dae1c248b72011-10-04 19:19:01 +09001089 },
1090};