2 * Copyright (C) 2013 Red Hat
3 * Author: Rob Clark <robdclark@gmail.com>
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program. If not, see <http://www.gnu.org/licenses/>.
23 static struct mdp4_platform_config
*mdp4_get_config(struct platform_device
*dev
);
25 static int mdp4_hw_init(struct msm_kms
*kms
)
27 struct mdp4_kms
*mdp4_kms
= to_mdp4_kms(kms
);
28 struct drm_device
*dev
= mdp4_kms
->dev
;
29 uint32_t version
, major
, minor
, dmap_cfg
, vg_cfg
;
33 pm_runtime_get_sync(dev
->dev
);
35 version
= mdp4_read(mdp4_kms
, REG_MDP4_VERSION
);
37 major
= FIELD(version
, MDP4_VERSION_MAJOR
);
38 minor
= FIELD(version
, MDP4_VERSION_MINOR
);
40 DBG("found MDP version v%d.%d", major
, minor
);
43 dev_err(dev
->dev
, "unexpected MDP version: v%d.%d\n",
49 mdp4_kms
->rev
= minor
;
51 if (mdp4_kms
->dsi_pll_vdda
) {
52 if ((mdp4_kms
->rev
== 2) || (mdp4_kms
->rev
== 4)) {
53 ret
= regulator_set_voltage(mdp4_kms
->dsi_pll_vdda
,
57 "failed to set dsi_pll_vdda voltage: %d\n", ret
);
63 if (mdp4_kms
->dsi_pll_vddio
) {
64 if (mdp4_kms
->rev
== 2) {
65 ret
= regulator_set_voltage(mdp4_kms
->dsi_pll_vddio
,
69 "failed to set dsi_pll_vddio voltage: %d\n", ret
);
75 if (mdp4_kms
->rev
> 1) {
76 mdp4_write(mdp4_kms
, REG_MDP4_CS_CONTROLLER0
, 0x0707ffff);
77 mdp4_write(mdp4_kms
, REG_MDP4_CS_CONTROLLER1
, 0x03073f3f);
80 mdp4_write(mdp4_kms
, REG_MDP4_PORTMAP_MODE
, 0x3);
82 /* max read pending cmd config, 3 pending requests: */
83 mdp4_write(mdp4_kms
, REG_MDP4_READ_CNFG
, 0x02222);
85 clk
= clk_get_rate(mdp4_kms
->clk
);
87 if ((mdp4_kms
->rev
>= 1) || (clk
>= 90000000)) {
88 dmap_cfg
= 0x47; /* 16 bytes-burst x 8 req */
89 vg_cfg
= 0x47; /* 16 bytes-burs x 8 req */
91 dmap_cfg
= 0x27; /* 8 bytes-burst x 8 req */
92 vg_cfg
= 0x43; /* 16 bytes-burst x 4 req */
95 DBG("fetch config: dmap=%02x, vg=%02x", dmap_cfg
, vg_cfg
);
97 mdp4_write(mdp4_kms
, REG_MDP4_DMA_FETCH_CONFIG(DMA_P
), dmap_cfg
);
98 mdp4_write(mdp4_kms
, REG_MDP4_DMA_FETCH_CONFIG(DMA_E
), dmap_cfg
);
100 mdp4_write(mdp4_kms
, REG_MDP4_PIPE_FETCH_CONFIG(VG1
), vg_cfg
);
101 mdp4_write(mdp4_kms
, REG_MDP4_PIPE_FETCH_CONFIG(VG2
), vg_cfg
);
102 mdp4_write(mdp4_kms
, REG_MDP4_PIPE_FETCH_CONFIG(RGB1
), vg_cfg
);
103 mdp4_write(mdp4_kms
, REG_MDP4_PIPE_FETCH_CONFIG(RGB2
), vg_cfg
);
105 if (mdp4_kms
->rev
>= 2)
106 mdp4_write(mdp4_kms
, REG_MDP4_LAYERMIXER_IN_CFG_UPDATE_METHOD
, 1);
108 /* disable CSC matrix / YUV by default: */
109 mdp4_write(mdp4_kms
, REG_MDP4_PIPE_OP_MODE(VG1
), 0);
110 mdp4_write(mdp4_kms
, REG_MDP4_PIPE_OP_MODE(VG2
), 0);
111 mdp4_write(mdp4_kms
, REG_MDP4_DMA_P_OP_MODE
, 0);
112 mdp4_write(mdp4_kms
, REG_MDP4_DMA_S_OP_MODE
, 0);
113 mdp4_write(mdp4_kms
, REG_MDP4_OVLP_CSC_CONFIG(1), 0);
114 mdp4_write(mdp4_kms
, REG_MDP4_OVLP_CSC_CONFIG(2), 0);
116 if (mdp4_kms
->rev
> 1)
117 mdp4_write(mdp4_kms
, REG_MDP4_RESET_STATUS
, 1);
120 pm_runtime_put_sync(dev
->dev
);
125 static long mdp4_round_pixclk(struct msm_kms
*kms
, unsigned long rate
,
126 struct drm_encoder
*encoder
)
128 /* if we had >1 encoder, we'd need something more clever: */
129 return mdp4_dtv_round_pixclk(encoder
, rate
);
132 static void mdp4_preclose(struct msm_kms
*kms
, struct drm_file
*file
)
134 struct mdp4_kms
*mdp4_kms
= to_mdp4_kms(kms
);
135 struct msm_drm_private
*priv
= mdp4_kms
->dev
->dev_private
;
138 for (i
= 0; i
< priv
->num_crtcs
; i
++)
139 mdp4_crtc_cancel_pending_flip(priv
->crtcs
[i
], file
);
142 static void mdp4_destroy(struct msm_kms
*kms
)
144 struct mdp4_kms
*mdp4_kms
= to_mdp4_kms(kms
);
148 static const struct msm_kms_funcs kms_funcs
= {
149 .hw_init
= mdp4_hw_init
,
150 .irq_preinstall
= mdp4_irq_preinstall
,
151 .irq_postinstall
= mdp4_irq_postinstall
,
152 .irq_uninstall
= mdp4_irq_uninstall
,
154 .enable_vblank
= mdp4_enable_vblank
,
155 .disable_vblank
= mdp4_disable_vblank
,
156 .get_format
= mdp4_get_format
,
157 .round_pixclk
= mdp4_round_pixclk
,
158 .preclose
= mdp4_preclose
,
159 .destroy
= mdp4_destroy
,
162 int mdp4_disable(struct mdp4_kms
*mdp4_kms
)
166 clk_disable_unprepare(mdp4_kms
->clk
);
168 clk_disable_unprepare(mdp4_kms
->pclk
);
169 clk_disable_unprepare(mdp4_kms
->lut_clk
);
174 int mdp4_enable(struct mdp4_kms
*mdp4_kms
)
178 clk_prepare_enable(mdp4_kms
->clk
);
180 clk_prepare_enable(mdp4_kms
->pclk
);
181 clk_prepare_enable(mdp4_kms
->lut_clk
);
186 static int modeset_init(struct mdp4_kms
*mdp4_kms
)
188 struct drm_device
*dev
= mdp4_kms
->dev
;
189 struct msm_drm_private
*priv
= dev
->dev_private
;
190 struct drm_plane
*plane
;
191 struct drm_crtc
*crtc
;
192 struct drm_encoder
*encoder
;
196 * NOTE: this is a bit simplistic until we add support
197 * for more than just RGB1->DMA_E->DTV->HDMI
200 /* construct non-private planes: */
201 plane
= mdp4_plane_init(dev
, VG1
, false);
203 dev_err(dev
->dev
, "failed to construct plane for VG1\n");
204 ret
= PTR_ERR(plane
);
207 priv
->planes
[priv
->num_planes
++] = plane
;
209 plane
= mdp4_plane_init(dev
, VG2
, false);
211 dev_err(dev
->dev
, "failed to construct plane for VG2\n");
212 ret
= PTR_ERR(plane
);
215 priv
->planes
[priv
->num_planes
++] = plane
;
217 /* the CRTCs get constructed with a private plane: */
218 plane
= mdp4_plane_init(dev
, RGB1
, true);
220 dev_err(dev
->dev
, "failed to construct plane for RGB1\n");
221 ret
= PTR_ERR(plane
);
225 crtc
= mdp4_crtc_init(dev
, plane
, priv
->num_crtcs
, 1, DMA_E
);
227 dev_err(dev
->dev
, "failed to construct crtc for DMA_E\n");
231 priv
->crtcs
[priv
->num_crtcs
++] = crtc
;
233 encoder
= mdp4_dtv_encoder_init(dev
);
234 if (IS_ERR(encoder
)) {
235 dev_err(dev
->dev
, "failed to construct DTV encoder\n");
236 ret
= PTR_ERR(encoder
);
239 encoder
->possible_crtcs
= 0x1; /* DTV can be hooked to DMA_E */
240 priv
->encoders
[priv
->num_encoders
++] = encoder
;
242 ret
= hdmi_init(dev
, encoder
);
244 dev_err(dev
->dev
, "failed to initialize HDMI\n");
254 static const char *iommu_ports
[] = {
255 "mdp_port0_cb0", "mdp_port1_cb0",
258 struct msm_kms
*mdp4_kms_init(struct drm_device
*dev
)
260 struct platform_device
*pdev
= dev
->platformdev
;
261 struct mdp4_platform_config
*config
= mdp4_get_config(pdev
);
262 struct mdp4_kms
*mdp4_kms
;
263 struct msm_kms
*kms
= NULL
;
267 mdp4_kms
= kzalloc(sizeof(*mdp4_kms
), GFP_KERNEL
);
269 dev_err(dev
->dev
, "failed to allocate kms\n");
274 kms
= &mdp4_kms
->base
;
275 kms
->funcs
= &kms_funcs
;
279 mdp4_kms
->mmio
= msm_ioremap(pdev
, NULL
, "MDP4");
280 if (IS_ERR(mdp4_kms
->mmio
)) {
281 ret
= PTR_ERR(mdp4_kms
->mmio
);
285 mdp4_kms
->dsi_pll_vdda
= devm_regulator_get(&pdev
->dev
, "dsi_pll_vdda");
286 if (IS_ERR(mdp4_kms
->dsi_pll_vdda
))
287 mdp4_kms
->dsi_pll_vdda
= NULL
;
289 mdp4_kms
->dsi_pll_vddio
= devm_regulator_get(&pdev
->dev
, "dsi_pll_vddio");
290 if (IS_ERR(mdp4_kms
->dsi_pll_vddio
))
291 mdp4_kms
->dsi_pll_vddio
= NULL
;
293 mdp4_kms
->vdd
= devm_regulator_get(&pdev
->dev
, "vdd");
294 if (IS_ERR(mdp4_kms
->vdd
))
295 mdp4_kms
->vdd
= NULL
;
298 ret
= regulator_enable(mdp4_kms
->vdd
);
300 dev_err(dev
->dev
, "failed to enable regulator vdd: %d\n", ret
);
305 mdp4_kms
->clk
= devm_clk_get(&pdev
->dev
, "core_clk");
306 if (IS_ERR(mdp4_kms
->clk
)) {
307 dev_err(dev
->dev
, "failed to get core_clk\n");
308 ret
= PTR_ERR(mdp4_kms
->clk
);
312 mdp4_kms
->pclk
= devm_clk_get(&pdev
->dev
, "iface_clk");
313 if (IS_ERR(mdp4_kms
->pclk
))
314 mdp4_kms
->pclk
= NULL
;
316 // XXX if (rev >= MDP_REV_42) { ???
317 mdp4_kms
->lut_clk
= devm_clk_get(&pdev
->dev
, "lut_clk");
318 if (IS_ERR(mdp4_kms
->lut_clk
)) {
319 dev_err(dev
->dev
, "failed to get lut_clk\n");
320 ret
= PTR_ERR(mdp4_kms
->lut_clk
);
324 clk_set_rate(mdp4_kms
->clk
, config
->max_clk
);
325 clk_set_rate(mdp4_kms
->lut_clk
, config
->max_clk
);
327 /* make sure things are off before attaching iommu (bootloader could
328 * have left things on, in which case we'll start getting faults if
331 mdp4_write(mdp4_kms
, REG_MDP4_DTV_ENABLE
, 0);
332 mdp4_write(mdp4_kms
, REG_MDP4_LCDC_ENABLE
, 0);
333 mdp4_write(mdp4_kms
, REG_MDP4_DSI_ENABLE
, 0);
337 mmu
= msm_iommu_new(dev
, config
->iommu
);
342 ret
= mmu
->funcs
->attach(mmu
, iommu_ports
,
343 ARRAY_SIZE(iommu_ports
));
347 dev_info(dev
->dev
, "no iommu, fallback to phys "
348 "contig buffers for scanout\n");
352 mdp4_kms
->id
= msm_register_mmu(dev
, mmu
);
353 if (mdp4_kms
->id
< 0) {
355 dev_err(dev
->dev
, "failed to register mdp4 iommu: %d\n", ret
);
359 ret
= modeset_init(mdp4_kms
);
361 dev_err(dev
->dev
, "modeset_init failed: %d\n", ret
);
373 static struct mdp4_platform_config
*mdp4_get_config(struct platform_device
*dev
)
375 static struct mdp4_platform_config config
= {};
379 if (cpu_is_apq8064())
380 config
.max_clk
= 266667000;
382 config
.max_clk
= 200000000;
384 config
.iommu
= msm_get_iommu_domain(DISPLAY_READ_DOMAIN
);