drm/mxsfb/lcdif_drv.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2022 Marek Vasut <marex@denx.de>
0004  *
0005  * This code is based on drivers/gpu/drm/mxsfb/mxsfb*
0006  */
0007
0008 #include <linux/clk.h>
0009 #include <linux/dma-mapping.h>
0010 #include <linux/io.h>
0011 #include <linux/iopoll.h>
0012 #include <linux/module.h>
0013 #include <linux/of_device.h>
0014 #include <linux/platform_device.h>
0015 #include <linux/pm_runtime.h>
0016
0017 #include <drm/drm_atomic_helper.h>
0018 #include <drm/drm_bridge.h>
0019 #include <drm/drm_connector.h>
0020 #include <drm/drm_drv.h>
0021 #include <drm/drm_fb_helper.h>
0022 #include <drm/drm_fourcc.h>
0023 #include <drm/drm_gem_cma_helper.h>
0024 #include <drm/drm_gem_framebuffer_helper.h>
0025 #include <drm/drm_mode_config.h>
0026 #include <drm/drm_module.h>
0027 #include <drm/drm_of.h>
0028 #include <drm/drm_probe_helper.h>
0029 #include <drm/drm_vblank.h>
0030
0031 #include "lcdif_drv.h"
0032 #include "lcdif_regs.h"
0033
0034 static const struct drm_mode_config_funcs lcdif_mode_config_funcs = {
0035     .fb_create      = drm_gem_fb_create,
0036     .atomic_check       = drm_atomic_helper_check,
0037     .atomic_commit      = drm_atomic_helper_commit,
0038 };
0039
0040 static const struct drm_mode_config_helper_funcs lcdif_mode_config_helpers = {
0041     .atomic_commit_tail = drm_atomic_helper_commit_tail_rpm,
0042 };
0043
0044 static int lcdif_attach_bridge(struct lcdif_drm_private *lcdif)
0045 {
0046     struct drm_device *drm = lcdif->drm;
0047     struct drm_bridge *bridge;
0048     struct drm_panel *panel;
0049     int ret;
0050
0051     ret = drm_of_find_panel_or_bridge(drm->dev->of_node, 0, 0, &panel,
0052                       &bridge);
0053     if (ret)
0054         return ret;
0055
0056     if (panel) {
0057         bridge = devm_drm_panel_bridge_add_typed(drm->dev, panel,
0058                              DRM_MODE_CONNECTOR_DPI);
0059         if (IS_ERR(bridge))
0060             return PTR_ERR(bridge);
0061     }
0062
0063     if (!bridge)
0064         return -ENODEV;
0065
0066     ret = drm_bridge_attach(&lcdif->encoder, bridge, NULL, 0);
0067     if (ret)
0068         return dev_err_probe(drm->dev, ret, "Failed to attach bridge\n");
0069
0070     lcdif->bridge = bridge;
0071
0072     return 0;
0073 }
0074
0075 static irqreturn_t lcdif_irq_handler(int irq, void *data)
0076 {
0077     struct drm_device *drm = data;
0078     struct lcdif_drm_private *lcdif = drm->dev_private;
0079     u32 reg, stat;
0080
0081     stat = readl(lcdif->base + LCDC_V8_INT_STATUS_D0);
0082     if (!stat)
0083         return IRQ_NONE;
0084
0085     if (stat & INT_STATUS_D0_VS_BLANK) {
0086         reg = readl(lcdif->base + LCDC_V8_CTRLDESCL0_5);
0087         if (!(reg & CTRLDESCL0_5_SHADOW_LOAD_EN))
0088             drm_crtc_handle_vblank(&lcdif->crtc);
0089     }
0090
0091     writel(stat, lcdif->base + LCDC_V8_INT_STATUS_D0);
0092
0093     return IRQ_HANDLED;
0094 }
0095
0096 static int lcdif_load(struct drm_device *drm)
0097 {
0098     struct platform_device *pdev = to_platform_device(drm->dev);
0099     struct lcdif_drm_private *lcdif;
0100     struct resource *res;
0101     int ret;
0102
0103     lcdif = devm_kzalloc(&pdev->dev, sizeof(*lcdif), GFP_KERNEL);
0104     if (!lcdif)
0105         return -ENOMEM;
0106
0107     lcdif->drm = drm;
0108     drm->dev_private = lcdif;
0109
0110     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0111     lcdif->base = devm_ioremap_resource(drm->dev, res);
0112     if (IS_ERR(lcdif->base))
0113         return PTR_ERR(lcdif->base);
0114
0115     lcdif->clk = devm_clk_get(drm->dev, "pix");
0116     if (IS_ERR(lcdif->clk))
0117         return PTR_ERR(lcdif->clk);
0118
0119     lcdif->clk_axi = devm_clk_get(drm->dev, "axi");
0120     if (IS_ERR(lcdif->clk_axi))
0121         return PTR_ERR(lcdif->clk_axi);
0122
0123     lcdif->clk_disp_axi = devm_clk_get(drm->dev, "disp_axi");
0124     if (IS_ERR(lcdif->clk_disp_axi))
0125         return PTR_ERR(lcdif->clk_disp_axi);
0126
0127     platform_set_drvdata(pdev, drm);
0128
0129     ret = dma_set_mask_and_coherent(drm->dev, DMA_BIT_MASK(36));
0130     if (ret)
0131         return ret;
0132
0133     /* Modeset init */
0134     drm_mode_config_init(drm);
0135
0136     ret = lcdif_kms_init(lcdif);
0137     if (ret < 0) {
0138         dev_err(drm->dev, "Failed to initialize KMS pipeline\n");
0139         return ret;
0140     }
0141
0142     ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
0143     if (ret < 0) {
0144         dev_err(drm->dev, "Failed to initialise vblank\n");
0145         return ret;
0146     }
0147
0148     /* Start with vertical blanking interrupt reporting disabled. */
0149     drm_crtc_vblank_off(&lcdif->crtc);
0150
0151     ret = lcdif_attach_bridge(lcdif);
0152     if (ret)
0153         return dev_err_probe(drm->dev, ret, "Cannot connect bridge\n");
0154
0155     drm->mode_config.min_width  = LCDIF_MIN_XRES;
0156     drm->mode_config.min_height = LCDIF_MIN_YRES;
0157     drm->mode_config.max_width  = LCDIF_MAX_XRES;
0158     drm->mode_config.max_height = LCDIF_MAX_YRES;
0159     drm->mode_config.funcs      = &lcdif_mode_config_funcs;
0160     drm->mode_config.helper_private = &lcdif_mode_config_helpers;
0161
0162     drm_mode_config_reset(drm);
0163
0164     ret = platform_get_irq(pdev, 0);
0165     if (ret < 0)
0166         return ret;
0167     lcdif->irq = ret;
0168
0169     ret = devm_request_irq(drm->dev, lcdif->irq, lcdif_irq_handler, 0,
0170                    drm->driver->name, drm);
0171     if (ret < 0) {
0172         dev_err(drm->dev, "Failed to install IRQ handler\n");
0173         return ret;
0174     }
0175
0176     drm_kms_helper_poll_init(drm);
0177
0178     drm_helper_hpd_irq_event(drm);
0179
0180     pm_runtime_enable(drm->dev);
0181
0182     return 0;
0183 }
0184
0185 static void lcdif_unload(struct drm_device *drm)
0186 {
0187     struct lcdif_drm_private *lcdif = drm->dev_private;
0188
0189     pm_runtime_get_sync(drm->dev);
0190
0191     drm_crtc_vblank_off(&lcdif->crtc);
0192
0193     drm_kms_helper_poll_fini(drm);
0194     drm_mode_config_cleanup(drm);
0195
0196     pm_runtime_put_sync(drm->dev);
0197     pm_runtime_disable(drm->dev);
0198
0199     drm->dev_private = NULL;
0200 }
0201
0202 DEFINE_DRM_GEM_CMA_FOPS(fops);
0203
0204 static const struct drm_driver lcdif_driver = {
0205     .driver_features    = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
0206     DRM_GEM_CMA_DRIVER_OPS,
0207     .fops   = &fops,
0208     .name   = "imx-lcdif",
0209     .desc   = "i.MX LCDIF Controller DRM",
0210     .date   = "20220417",
0211     .major  = 1,
0212     .minor  = 0,
0213 };
0214
0215 static const struct of_device_id lcdif_dt_ids[] = {
0216     { .compatible = "fsl,imx8mp-lcdif" },
0217     { /* sentinel */ }
0218 };
0219 MODULE_DEVICE_TABLE(of, lcdif_dt_ids);
0220
0221 static int lcdif_probe(struct platform_device *pdev)
0222 {
0223     struct drm_device *drm;
0224     int ret;
0225
0226     drm = drm_dev_alloc(&lcdif_driver, &pdev->dev);
0227     if (IS_ERR(drm))
0228         return PTR_ERR(drm);
0229
0230     ret = lcdif_load(drm);
0231     if (ret)
0232         goto err_free;
0233
0234     ret = drm_dev_register(drm, 0);
0235     if (ret)
0236         goto err_unload;
0237
0238     drm_fbdev_generic_setup(drm, 32);
0239
0240     return 0;
0241
0242 err_unload:
0243     lcdif_unload(drm);
0244 err_free:
0245     drm_dev_put(drm);
0246
0247     return ret;
0248 }
0249
0250 static int lcdif_remove(struct platform_device *pdev)
0251 {
0252     struct drm_device *drm = platform_get_drvdata(pdev);
0253
0254     drm_dev_unregister(drm);
0255     drm_atomic_helper_shutdown(drm);
0256     lcdif_unload(drm);
0257     drm_dev_put(drm);
0258
0259     return 0;
0260 }
0261
0262 static void lcdif_shutdown(struct platform_device *pdev)
0263 {
0264     struct drm_device *drm = platform_get_drvdata(pdev);
0265
0266     drm_atomic_helper_shutdown(drm);
0267 }
0268
0269 static int __maybe_unused lcdif_rpm_suspend(struct device *dev)
0270 {
0271     struct drm_device *drm = dev_get_drvdata(dev);
0272     struct lcdif_drm_private *lcdif = drm->dev_private;
0273
0274     /* These clock supply the DISPLAY CLOCK Domain */
0275     clk_disable_unprepare(lcdif->clk);
0276     /* These clock supply the System Bus, AXI, Write Path, LFIFO */
0277     clk_disable_unprepare(lcdif->clk_disp_axi);
0278     /* These clock supply the Control Bus, APB, APBH Ctrl Registers */
0279     clk_disable_unprepare(lcdif->clk_axi);
0280
0281     return 0;
0282 }
0283
0284 static int __maybe_unused lcdif_rpm_resume(struct device *dev)
0285 {
0286     struct drm_device *drm = dev_get_drvdata(dev);
0287     struct lcdif_drm_private *lcdif = drm->dev_private;
0288
0289     /* These clock supply the Control Bus, APB, APBH Ctrl Registers */
0290     clk_prepare_enable(lcdif->clk_axi);
0291     /* These clock supply the System Bus, AXI, Write Path, LFIFO */
0292     clk_prepare_enable(lcdif->clk_disp_axi);
0293     /* These clock supply the DISPLAY CLOCK Domain */
0294     clk_prepare_enable(lcdif->clk);
0295
0296     return 0;
0297 }
0298
0299 static int __maybe_unused lcdif_suspend(struct device *dev)
0300 {
0301     struct drm_device *drm = dev_get_drvdata(dev);
0302     int ret;
0303
0304     ret = drm_mode_config_helper_suspend(drm);
0305     if (ret)
0306         return ret;
0307
0308     return lcdif_rpm_suspend(dev);
0309 }
0310
0311 static int __maybe_unused lcdif_resume(struct device *dev)
0312 {
0313     struct drm_device *drm = dev_get_drvdata(dev);
0314
0315     lcdif_rpm_resume(dev);
0316
0317     return drm_mode_config_helper_resume(drm);
0318 }
0319
0320 static const struct dev_pm_ops lcdif_pm_ops = {
0321     SET_SYSTEM_SLEEP_PM_OPS(lcdif_suspend, lcdif_resume)
0322     SET_RUNTIME_PM_OPS(lcdif_rpm_suspend, lcdif_rpm_resume, NULL)
0323 };
0324
0325 static struct platform_driver lcdif_platform_driver = {
0326     .probe      = lcdif_probe,
0327     .remove     = lcdif_remove,
0328     .shutdown   = lcdif_shutdown,
0329     .driver = {
0330         .name       = "imx-lcdif",
0331         .of_match_table = lcdif_dt_ids,
0332         .pm     = &lcdif_pm_ops,
0333     },
0334 };
0335
0336 drm_module_platform_driver(lcdif_platform_driver);
0337
0338 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
0339 MODULE_DESCRIPTION("Freescale LCDIF DRM/KMS driver");
0340 MODULE_LICENSE("GPL");