2 * Copyright (C) 2016 Marek Vasut <marex@denx.de>
4 * This code is based on drivers/video/fbdev/mxsfb.c :
5 * Copyright (C) 2010 Juergen Beisert, Pengutronix
6 * Copyright (C) 2008-2009 Freescale Semiconductor, Inc. All Rights Reserved.
7 * Copyright (C) 2008 Embedded Alley Solutions, Inc All Rights Reserved.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
19 #include <linux/module.h>
20 #include <linux/spinlock.h>
21 #include <linux/clk.h>
22 #include <linux/component.h>
23 #include <linux/list.h>
24 #include <linux/of_device.h>
25 #include <linux/of_graph.h>
26 #include <linux/of_reserved_mem.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/reservation.h>
31 #include <drm/drm_atomic.h>
32 #include <drm/drm_atomic_helper.h>
33 #include <drm/drm_crtc.h>
34 #include <drm/drm_crtc_helper.h>
35 #include <drm/drm_fb_helper.h>
36 #include <drm/drm_fb_cma_helper.h>
37 #include <drm/drm_gem_cma_helper.h>
38 #include <drm/drm_of.h>
39 #include <drm/drm_panel.h>
40 #include <drm/drm_simple_kms_helper.h>
42 #include "mxsfb_drv.h"
43 #include "mxsfb_regs.h"
50 static const struct mxsfb_devdata mxsfb_devdata
[] = {
52 .transfer_count
= LCDC_V3_TRANSFER_COUNT
,
53 .cur_buf
= LCDC_V3_CUR_BUF
,
54 .next_buf
= LCDC_V3_NEXT_BUF
,
55 .debug0
= LCDC_V3_DEBUG0
,
61 .transfer_count
= LCDC_V4_TRANSFER_COUNT
,
62 .cur_buf
= LCDC_V4_CUR_BUF
,
63 .next_buf
= LCDC_V4_NEXT_BUF
,
64 .debug0
= LCDC_V4_DEBUG0
,
65 .hs_wdth_mask
= 0x3fff,
71 static const uint32_t mxsfb_formats
[] = {
76 static struct mxsfb_drm_private
*
77 drm_pipe_to_mxsfb_drm_private(struct drm_simple_display_pipe
*pipe
)
79 return container_of(pipe
, struct mxsfb_drm_private
, pipe
);
82 void mxsfb_enable_axi_clk(struct mxsfb_drm_private
*mxsfb
)
85 clk_prepare_enable(mxsfb
->clk_axi
);
88 void mxsfb_disable_axi_clk(struct mxsfb_drm_private
*mxsfb
)
91 clk_disable_unprepare(mxsfb
->clk_axi
);
94 static const struct drm_mode_config_funcs mxsfb_mode_config_funcs
= {
95 .fb_create
= drm_fb_cma_create
,
96 .atomic_check
= drm_atomic_helper_check
,
97 .atomic_commit
= drm_atomic_helper_commit
,
100 static void mxsfb_pipe_enable(struct drm_simple_display_pipe
*pipe
,
101 struct drm_crtc_state
*crtc_state
)
103 struct mxsfb_drm_private
*mxsfb
= drm_pipe_to_mxsfb_drm_private(pipe
);
105 mxsfb_crtc_enable(mxsfb
);
108 static void mxsfb_pipe_disable(struct drm_simple_display_pipe
*pipe
)
110 struct mxsfb_drm_private
*mxsfb
= drm_pipe_to_mxsfb_drm_private(pipe
);
112 mxsfb_crtc_disable(mxsfb
);
115 static void mxsfb_pipe_update(struct drm_simple_display_pipe
*pipe
,
116 struct drm_plane_state
*plane_state
)
118 struct mxsfb_drm_private
*mxsfb
= drm_pipe_to_mxsfb_drm_private(pipe
);
120 mxsfb_plane_atomic_update(mxsfb
, plane_state
);
123 static int mxsfb_pipe_prepare_fb(struct drm_simple_display_pipe
*pipe
,
124 struct drm_plane_state
*plane_state
)
126 return drm_fb_cma_prepare_fb(&pipe
->plane
, plane_state
);
129 static struct drm_simple_display_pipe_funcs mxsfb_funcs
= {
130 .enable
= mxsfb_pipe_enable
,
131 .disable
= mxsfb_pipe_disable
,
132 .update
= mxsfb_pipe_update
,
133 .prepare_fb
= mxsfb_pipe_prepare_fb
,
136 static int mxsfb_load(struct drm_device
*drm
, unsigned long flags
)
138 struct platform_device
*pdev
= to_platform_device(drm
->dev
);
139 struct mxsfb_drm_private
*mxsfb
;
140 struct resource
*res
;
143 mxsfb
= devm_kzalloc(&pdev
->dev
, sizeof(*mxsfb
), GFP_KERNEL
);
147 drm
->dev_private
= mxsfb
;
148 mxsfb
->devdata
= &mxsfb_devdata
[pdev
->id_entry
->driver_data
];
150 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
151 mxsfb
->base
= devm_ioremap_resource(drm
->dev
, res
);
152 if (IS_ERR(mxsfb
->base
))
153 return PTR_ERR(mxsfb
->base
);
155 mxsfb
->clk
= devm_clk_get(drm
->dev
, NULL
);
156 if (IS_ERR(mxsfb
->clk
))
157 return PTR_ERR(mxsfb
->clk
);
159 mxsfb
->clk_axi
= devm_clk_get(drm
->dev
, "axi");
160 if (IS_ERR(mxsfb
->clk_axi
))
161 mxsfb
->clk_axi
= NULL
;
163 mxsfb
->clk_disp_axi
= devm_clk_get(drm
->dev
, "disp_axi");
164 if (IS_ERR(mxsfb
->clk_disp_axi
))
165 mxsfb
->clk_disp_axi
= NULL
;
167 ret
= dma_set_mask_and_coherent(drm
->dev
, DMA_BIT_MASK(32));
171 pm_runtime_enable(drm
->dev
);
173 ret
= drm_vblank_init(drm
, drm
->mode_config
.num_crtc
);
175 dev_err(drm
->dev
, "Failed to initialise vblank\n");
180 drm_mode_config_init(drm
);
182 ret
= mxsfb_create_output(drm
);
184 dev_err(drm
->dev
, "Failed to create outputs\n");
188 ret
= drm_simple_display_pipe_init(drm
, &mxsfb
->pipe
, &mxsfb_funcs
,
189 mxsfb_formats
, ARRAY_SIZE(mxsfb_formats
),
192 dev_err(drm
->dev
, "Cannot setup simple display pipe\n");
196 ret
= drm_panel_attach(mxsfb
->panel
, &mxsfb
->connector
);
198 dev_err(drm
->dev
, "Cannot connect panel\n");
202 drm
->mode_config
.min_width
= MXSFB_MIN_XRES
;
203 drm
->mode_config
.min_height
= MXSFB_MIN_YRES
;
204 drm
->mode_config
.max_width
= MXSFB_MAX_XRES
;
205 drm
->mode_config
.max_height
= MXSFB_MAX_YRES
;
206 drm
->mode_config
.funcs
= &mxsfb_mode_config_funcs
;
208 drm_mode_config_reset(drm
);
210 pm_runtime_get_sync(drm
->dev
);
211 ret
= drm_irq_install(drm
, platform_get_irq(pdev
, 0));
212 pm_runtime_put_sync(drm
->dev
);
215 dev_err(drm
->dev
, "Failed to install IRQ handler\n");
219 drm_kms_helper_poll_init(drm
);
221 mxsfb
->fbdev
= drm_fbdev_cma_init(drm
, 32,
222 drm
->mode_config
.num_connector
);
223 if (IS_ERR(mxsfb
->fbdev
)) {
224 ret
= PTR_ERR(mxsfb
->fbdev
);
226 dev_err(drm
->dev
, "Failed to init FB CMA area\n");
230 platform_set_drvdata(pdev
, drm
);
232 drm_helper_hpd_irq_event(drm
);
237 drm_irq_uninstall(drm
);
239 drm_panel_detach(mxsfb
->panel
);
241 pm_runtime_disable(drm
->dev
);
246 static void mxsfb_unload(struct drm_device
*drm
)
248 struct mxsfb_drm_private
*mxsfb
= drm
->dev_private
;
251 drm_fbdev_cma_fini(mxsfb
->fbdev
);
253 drm_kms_helper_poll_fini(drm
);
254 drm_mode_config_cleanup(drm
);
255 drm_vblank_cleanup(drm
);
257 pm_runtime_get_sync(drm
->dev
);
258 drm_irq_uninstall(drm
);
259 pm_runtime_put_sync(drm
->dev
);
261 drm
->dev_private
= NULL
;
263 pm_runtime_disable(drm
->dev
);
266 static void mxsfb_lastclose(struct drm_device
*drm
)
268 struct mxsfb_drm_private
*mxsfb
= drm
->dev_private
;
270 drm_fbdev_cma_restore_mode(mxsfb
->fbdev
);
273 static int mxsfb_enable_vblank(struct drm_device
*drm
, unsigned int crtc
)
275 struct mxsfb_drm_private
*mxsfb
= drm
->dev_private
;
277 /* Clear and enable VBLANK IRQ */
278 mxsfb_enable_axi_clk(mxsfb
);
279 writel(CTRL1_CUR_FRAME_DONE_IRQ
, mxsfb
->base
+ LCDC_CTRL1
+ REG_CLR
);
280 writel(CTRL1_CUR_FRAME_DONE_IRQ_EN
, mxsfb
->base
+ LCDC_CTRL1
+ REG_SET
);
281 mxsfb_disable_axi_clk(mxsfb
);
286 static void mxsfb_disable_vblank(struct drm_device
*drm
, unsigned int crtc
)
288 struct mxsfb_drm_private
*mxsfb
= drm
->dev_private
;
290 /* Disable and clear VBLANK IRQ */
291 mxsfb_enable_axi_clk(mxsfb
);
292 writel(CTRL1_CUR_FRAME_DONE_IRQ_EN
, mxsfb
->base
+ LCDC_CTRL1
+ REG_CLR
);
293 writel(CTRL1_CUR_FRAME_DONE_IRQ
, mxsfb
->base
+ LCDC_CTRL1
+ REG_CLR
);
294 mxsfb_disable_axi_clk(mxsfb
);
297 static void mxsfb_irq_preinstall(struct drm_device
*drm
)
299 mxsfb_disable_vblank(drm
, 0);
302 static irqreturn_t
mxsfb_irq_handler(int irq
, void *data
)
304 struct drm_device
*drm
= data
;
305 struct mxsfb_drm_private
*mxsfb
= drm
->dev_private
;
308 mxsfb_enable_axi_clk(mxsfb
);
310 reg
= readl(mxsfb
->base
+ LCDC_CTRL1
);
312 if (reg
& CTRL1_CUR_FRAME_DONE_IRQ
)
313 drm_crtc_handle_vblank(&mxsfb
->pipe
.crtc
);
315 writel(CTRL1_CUR_FRAME_DONE_IRQ
, mxsfb
->base
+ LCDC_CTRL1
+ REG_CLR
);
317 mxsfb_disable_axi_clk(mxsfb
);
322 static const struct file_operations fops
= {
323 .owner
= THIS_MODULE
,
325 .release
= drm_release
,
326 .unlocked_ioctl
= drm_ioctl
,
328 .compat_ioctl
= drm_compat_ioctl
,
332 .llseek
= noop_llseek
,
333 .mmap
= drm_gem_cma_mmap
,
336 static struct drm_driver mxsfb_driver
= {
337 .driver_features
= DRIVER_GEM
| DRIVER_MODESET
|
338 DRIVER_PRIME
| DRIVER_ATOMIC
|
340 .lastclose
= mxsfb_lastclose
,
341 .irq_handler
= mxsfb_irq_handler
,
342 .irq_preinstall
= mxsfb_irq_preinstall
,
343 .irq_uninstall
= mxsfb_irq_preinstall
,
344 .enable_vblank
= mxsfb_enable_vblank
,
345 .disable_vblank
= mxsfb_disable_vblank
,
346 .gem_free_object
= drm_gem_cma_free_object
,
347 .gem_vm_ops
= &drm_gem_cma_vm_ops
,
348 .dumb_create
= drm_gem_cma_dumb_create
,
349 .dumb_map_offset
= drm_gem_cma_dumb_map_offset
,
350 .dumb_destroy
= drm_gem_dumb_destroy
,
351 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
352 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
353 .gem_prime_export
= drm_gem_prime_export
,
354 .gem_prime_import
= drm_gem_prime_import
,
355 .gem_prime_get_sg_table
= drm_gem_cma_prime_get_sg_table
,
356 .gem_prime_import_sg_table
= drm_gem_cma_prime_import_sg_table
,
357 .gem_prime_vmap
= drm_gem_cma_prime_vmap
,
358 .gem_prime_vunmap
= drm_gem_cma_prime_vunmap
,
359 .gem_prime_mmap
= drm_gem_cma_prime_mmap
,
362 .desc
= "MXSFB Controller DRM",
368 static const struct platform_device_id mxsfb_devtype
[] = {
369 { .name
= "imx23-fb", .driver_data
= MXSFB_V3
, },
370 { .name
= "imx28-fb", .driver_data
= MXSFB_V4
, },
371 { .name
= "imx6sx-fb", .driver_data
= MXSFB_V4
, },
374 MODULE_DEVICE_TABLE(platform
, mxsfb_devtype
);
376 static const struct of_device_id mxsfb_dt_ids
[] = {
377 { .compatible
= "fsl,imx23-lcdif", .data
= &mxsfb_devtype
[0], },
378 { .compatible
= "fsl,imx28-lcdif", .data
= &mxsfb_devtype
[1], },
379 { .compatible
= "fsl,imx6sx-lcdif", .data
= &mxsfb_devtype
[2], },
382 MODULE_DEVICE_TABLE(of
, mxsfb_dt_ids
);
384 static int mxsfb_probe(struct platform_device
*pdev
)
386 struct drm_device
*drm
;
387 const struct of_device_id
*of_id
=
388 of_match_device(mxsfb_dt_ids
, &pdev
->dev
);
391 if (!pdev
->dev
.of_node
)
395 pdev
->id_entry
= of_id
->data
;
397 drm
= drm_dev_alloc(&mxsfb_driver
, &pdev
->dev
);
401 ret
= mxsfb_load(drm
, 0);
405 ret
= drm_dev_register(drm
, 0);
419 static int mxsfb_remove(struct platform_device
*pdev
)
421 struct drm_device
*drm
= platform_get_drvdata(pdev
);
423 drm_dev_unregister(drm
);
430 static struct platform_driver mxsfb_platform_driver
= {
431 .probe
= mxsfb_probe
,
432 .remove
= mxsfb_remove
,
433 .id_table
= mxsfb_devtype
,
436 .of_match_table
= mxsfb_dt_ids
,
440 module_platform_driver(mxsfb_platform_driver
);
442 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
443 MODULE_DESCRIPTION("Freescale MXS DRM/KMS driver");
444 MODULE_LICENSE("GPL");