drm/mxsfb/mxsfb_drv.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2016 Marek Vasut <marex@denx.de>
0004  *
0005  * This code is based on drivers/video/fbdev/mxsfb.c :
0006  * Copyright (C) 2010 Juergen Beisert, Pengutronix
0007  * Copyright (C) 2008-2009 Freescale Semiconductor, Inc. All Rights Reserved.
0008  * Copyright (C) 2008 Embedded Alley Solutions, Inc All Rights Reserved.
0009  */
0010
0011 #include <linux/clk.h>
0012 #include <linux/dma-mapping.h>
0013 #include <linux/io.h>
0014 #include <linux/module.h>
0015 #include <linux/of_device.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/pm_runtime.h>
0018
0019 #include <drm/drm_atomic_helper.h>
0020 #include <drm/drm_bridge.h>
0021 #include <drm/drm_connector.h>
0022 #include <drm/drm_drv.h>
0023 #include <drm/drm_fb_helper.h>
0024 #include <drm/drm_fourcc.h>
0025 #include <drm/drm_gem_cma_helper.h>
0026 #include <drm/drm_gem_framebuffer_helper.h>
0027 #include <drm/drm_mode_config.h>
0028 #include <drm/drm_module.h>
0029 #include <drm/drm_of.h>
0030 #include <drm/drm_probe_helper.h>
0031 #include <drm/drm_vblank.h>
0032
0033 #include "mxsfb_drv.h"
0034 #include "mxsfb_regs.h"
0035
0036 enum mxsfb_devtype {
0037     MXSFB_V3,
0038     MXSFB_V4,
0039     /*
0040      * Starting at i.MX6 the hardware version register is gone, use the
0041      * i.MX family number as the version.
0042      */
0043     MXSFB_V6,
0044 };
0045
0046 static const struct mxsfb_devdata mxsfb_devdata[] = {
0047     [MXSFB_V3] = {
0048         .transfer_count = LCDC_V3_TRANSFER_COUNT,
0049         .cur_buf    = LCDC_V3_CUR_BUF,
0050         .next_buf   = LCDC_V3_NEXT_BUF,
0051         .hs_wdth_mask   = 0xff,
0052         .hs_wdth_shift  = 24,
0053         .has_overlay    = false,
0054         .has_ctrl2  = false,
0055         .has_crc32  = false,
0056     },
0057     [MXSFB_V4] = {
0058         .transfer_count = LCDC_V4_TRANSFER_COUNT,
0059         .cur_buf    = LCDC_V4_CUR_BUF,
0060         .next_buf   = LCDC_V4_NEXT_BUF,
0061         .hs_wdth_mask   = 0x3fff,
0062         .hs_wdth_shift  = 18,
0063         .has_overlay    = false,
0064         .has_ctrl2  = true,
0065         .has_crc32  = true,
0066     },
0067     [MXSFB_V6] = {
0068         .transfer_count = LCDC_V4_TRANSFER_COUNT,
0069         .cur_buf    = LCDC_V4_CUR_BUF,
0070         .next_buf   = LCDC_V4_NEXT_BUF,
0071         .hs_wdth_mask   = 0x3fff,
0072         .hs_wdth_shift  = 18,
0073         .has_overlay    = true,
0074         .has_ctrl2  = true,
0075         .has_crc32  = true,
0076     },
0077 };
0078
0079 void mxsfb_enable_axi_clk(struct mxsfb_drm_private *mxsfb)
0080 {
0081     if (mxsfb->clk_axi)
0082         clk_prepare_enable(mxsfb->clk_axi);
0083 }
0084
0085 void mxsfb_disable_axi_clk(struct mxsfb_drm_private *mxsfb)
0086 {
0087     if (mxsfb->clk_axi)
0088         clk_disable_unprepare(mxsfb->clk_axi);
0089 }
0090
0091 static struct drm_framebuffer *
0092 mxsfb_fb_create(struct drm_device *dev, struct drm_file *file_priv,
0093         const struct drm_mode_fb_cmd2 *mode_cmd)
0094 {
0095     const struct drm_format_info *info;
0096
0097     info = drm_get_format_info(dev, mode_cmd);
0098     if (!info)
0099         return ERR_PTR(-EINVAL);
0100
0101     if (mode_cmd->width * info->cpp[0] != mode_cmd->pitches[0]) {
0102         dev_dbg(dev->dev, "Invalid pitch: fb width must match pitch\n");
0103         return ERR_PTR(-EINVAL);
0104     }
0105
0106     return drm_gem_fb_create(dev, file_priv, mode_cmd);
0107 }
0108
0109 static const struct drm_mode_config_funcs mxsfb_mode_config_funcs = {
0110     .fb_create      = mxsfb_fb_create,
0111     .atomic_check       = drm_atomic_helper_check,
0112     .atomic_commit      = drm_atomic_helper_commit,
0113 };
0114
0115 static const struct drm_mode_config_helper_funcs mxsfb_mode_config_helpers = {
0116     .atomic_commit_tail = drm_atomic_helper_commit_tail_rpm,
0117 };
0118
0119 static int mxsfb_attach_bridge(struct mxsfb_drm_private *mxsfb)
0120 {
0121     struct drm_device *drm = mxsfb->drm;
0122     struct drm_connector_list_iter iter;
0123     struct drm_panel *panel;
0124     struct drm_bridge *bridge;
0125     int ret;
0126
0127     ret = drm_of_find_panel_or_bridge(drm->dev->of_node, 0, 0, &panel,
0128                       &bridge);
0129     if (ret)
0130         return ret;
0131
0132     if (panel) {
0133         bridge = devm_drm_panel_bridge_add_typed(drm->dev, panel,
0134                              DRM_MODE_CONNECTOR_DPI);
0135         if (IS_ERR(bridge))
0136             return PTR_ERR(bridge);
0137     }
0138
0139     if (!bridge)
0140         return -ENODEV;
0141
0142     ret = drm_bridge_attach(&mxsfb->encoder, bridge, NULL, 0);
0143     if (ret)
0144         return dev_err_probe(drm->dev, ret, "Failed to attach bridge\n");
0145
0146     mxsfb->bridge = bridge;
0147
0148     /*
0149      * Get hold of the connector. This is a bit of a hack, until the bridge
0150      * API gives us bus flags and formats.
0151      */
0152     drm_connector_list_iter_begin(drm, &iter);
0153     mxsfb->connector = drm_connector_list_iter_next(&iter);
0154     drm_connector_list_iter_end(&iter);
0155
0156     return 0;
0157 }
0158
0159 static irqreturn_t mxsfb_irq_handler(int irq, void *data)
0160 {
0161     struct drm_device *drm = data;
0162     struct mxsfb_drm_private *mxsfb = drm->dev_private;
0163     u32 reg, crc;
0164     u64 vbc;
0165
0166     reg = readl(mxsfb->base + LCDC_CTRL1);
0167
0168     if (reg & CTRL1_CUR_FRAME_DONE_IRQ) {
0169         drm_crtc_handle_vblank(&mxsfb->crtc);
0170         if (mxsfb->crc_active) {
0171             crc = readl(mxsfb->base + LCDC_V4_CRC_STAT);
0172             vbc = drm_crtc_accurate_vblank_count(&mxsfb->crtc);
0173             drm_crtc_add_crc_entry(&mxsfb->crtc, true, vbc, &crc);
0174         }
0175     }
0176
0177     writel(CTRL1_CUR_FRAME_DONE_IRQ, mxsfb->base + LCDC_CTRL1 + REG_CLR);
0178
0179     return IRQ_HANDLED;
0180 }
0181
0182 static void mxsfb_irq_disable(struct drm_device *drm)
0183 {
0184     struct mxsfb_drm_private *mxsfb = drm->dev_private;
0185
0186     mxsfb_enable_axi_clk(mxsfb);
0187
0188     /* Disable and clear VBLANK IRQ */
0189     writel(CTRL1_CUR_FRAME_DONE_IRQ_EN, mxsfb->base + LCDC_CTRL1 + REG_CLR);
0190     writel(CTRL1_CUR_FRAME_DONE_IRQ, mxsfb->base + LCDC_CTRL1 + REG_CLR);
0191
0192     mxsfb_disable_axi_clk(mxsfb);
0193 }
0194
0195 static int mxsfb_irq_install(struct drm_device *dev, int irq)
0196 {
0197     if (irq == IRQ_NOTCONNECTED)
0198         return -ENOTCONN;
0199
0200     mxsfb_irq_disable(dev);
0201
0202     return request_irq(irq, mxsfb_irq_handler, 0,  dev->driver->name, dev);
0203 }
0204
0205 static void mxsfb_irq_uninstall(struct drm_device *dev)
0206 {
0207     struct mxsfb_drm_private *mxsfb = dev->dev_private;
0208
0209     mxsfb_irq_disable(dev);
0210     free_irq(mxsfb->irq, dev);
0211 }
0212
0213 static int mxsfb_load(struct drm_device *drm,
0214               const struct mxsfb_devdata *devdata)
0215 {
0216     struct platform_device *pdev = to_platform_device(drm->dev);
0217     struct mxsfb_drm_private *mxsfb;
0218     struct resource *res;
0219     int ret;
0220
0221     mxsfb = devm_kzalloc(&pdev->dev, sizeof(*mxsfb), GFP_KERNEL);
0222     if (!mxsfb)
0223         return -ENOMEM;
0224
0225     mxsfb->drm = drm;
0226     drm->dev_private = mxsfb;
0227     mxsfb->devdata = devdata;
0228
0229     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0230     mxsfb->base = devm_ioremap_resource(drm->dev, res);
0231     if (IS_ERR(mxsfb->base))
0232         return PTR_ERR(mxsfb->base);
0233
0234     mxsfb->clk = devm_clk_get(drm->dev, NULL);
0235     if (IS_ERR(mxsfb->clk))
0236         return PTR_ERR(mxsfb->clk);
0237
0238     mxsfb->clk_axi = devm_clk_get(drm->dev, "axi");
0239     if (IS_ERR(mxsfb->clk_axi))
0240         mxsfb->clk_axi = NULL;
0241
0242     mxsfb->clk_disp_axi = devm_clk_get(drm->dev, "disp_axi");
0243     if (IS_ERR(mxsfb->clk_disp_axi))
0244         mxsfb->clk_disp_axi = NULL;
0245
0246     ret = dma_set_mask_and_coherent(drm->dev, DMA_BIT_MASK(32));
0247     if (ret)
0248         return ret;
0249
0250     pm_runtime_enable(drm->dev);
0251
0252     /* Modeset init */
0253     drm_mode_config_init(drm);
0254
0255     ret = mxsfb_kms_init(mxsfb);
0256     if (ret < 0) {
0257         dev_err(drm->dev, "Failed to initialize KMS pipeline\n");
0258         goto err_vblank;
0259     }
0260
0261     ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
0262     if (ret < 0) {
0263         dev_err(drm->dev, "Failed to initialise vblank\n");
0264         goto err_vblank;
0265     }
0266
0267     /* Start with vertical blanking interrupt reporting disabled. */
0268     drm_crtc_vblank_off(&mxsfb->crtc);
0269
0270     ret = mxsfb_attach_bridge(mxsfb);
0271     if (ret) {
0272         dev_err_probe(drm->dev, ret, "Cannot connect bridge\n");
0273         goto err_vblank;
0274     }
0275
0276     drm->mode_config.min_width  = MXSFB_MIN_XRES;
0277     drm->mode_config.min_height = MXSFB_MIN_YRES;
0278     drm->mode_config.max_width  = MXSFB_MAX_XRES;
0279     drm->mode_config.max_height = MXSFB_MAX_YRES;
0280     drm->mode_config.funcs      = &mxsfb_mode_config_funcs;
0281     drm->mode_config.helper_private = &mxsfb_mode_config_helpers;
0282
0283     drm_mode_config_reset(drm);
0284
0285     ret = platform_get_irq(pdev, 0);
0286     if (ret < 0)
0287         goto err_vblank;
0288     mxsfb->irq = ret;
0289
0290     pm_runtime_get_sync(drm->dev);
0291     ret = mxsfb_irq_install(drm, mxsfb->irq);
0292     pm_runtime_put_sync(drm->dev);
0293
0294     if (ret < 0) {
0295         dev_err(drm->dev, "Failed to install IRQ handler\n");
0296         goto err_vblank;
0297     }
0298
0299     drm_kms_helper_poll_init(drm);
0300
0301     platform_set_drvdata(pdev, drm);
0302
0303     drm_helper_hpd_irq_event(drm);
0304
0305     return 0;
0306
0307 err_vblank:
0308     pm_runtime_disable(drm->dev);
0309
0310     return ret;
0311 }
0312
0313 static void mxsfb_unload(struct drm_device *drm)
0314 {
0315     drm_kms_helper_poll_fini(drm);
0316     drm_mode_config_cleanup(drm);
0317
0318     pm_runtime_get_sync(drm->dev);
0319     mxsfb_irq_uninstall(drm);
0320     pm_runtime_put_sync(drm->dev);
0321
0322     drm->dev_private = NULL;
0323
0324     pm_runtime_disable(drm->dev);
0325 }
0326
0327 DEFINE_DRM_GEM_CMA_FOPS(fops);
0328
0329 static const struct drm_driver mxsfb_driver = {
0330     .driver_features    = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
0331     DRM_GEM_CMA_DRIVER_OPS,
0332     .fops   = &fops,
0333     .name   = "mxsfb-drm",
0334     .desc   = "MXSFB Controller DRM",
0335     .date   = "20160824",
0336     .major  = 1,
0337     .minor  = 0,
0338 };
0339
0340 static const struct of_device_id mxsfb_dt_ids[] = {
0341     { .compatible = "fsl,imx23-lcdif", .data = &mxsfb_devdata[MXSFB_V3], },
0342     { .compatible = "fsl,imx28-lcdif", .data = &mxsfb_devdata[MXSFB_V4], },
0343     { .compatible = "fsl,imx6sx-lcdif", .data = &mxsfb_devdata[MXSFB_V6], },
0344     { /* sentinel */ }
0345 };
0346 MODULE_DEVICE_TABLE(of, mxsfb_dt_ids);
0347
0348 static int mxsfb_probe(struct platform_device *pdev)
0349 {
0350     struct drm_device *drm;
0351     const struct of_device_id *of_id =
0352             of_match_device(mxsfb_dt_ids, &pdev->dev);
0353     int ret;
0354
0355     if (!pdev->dev.of_node)
0356         return -ENODEV;
0357
0358     drm = drm_dev_alloc(&mxsfb_driver, &pdev->dev);
0359     if (IS_ERR(drm))
0360         return PTR_ERR(drm);
0361
0362     ret = mxsfb_load(drm, of_id->data);
0363     if (ret)
0364         goto err_free;
0365
0366     ret = drm_dev_register(drm, 0);
0367     if (ret)
0368         goto err_unload;
0369
0370     drm_fbdev_generic_setup(drm, 32);
0371
0372     return 0;
0373
0374 err_unload:
0375     mxsfb_unload(drm);
0376 err_free:
0377     drm_dev_put(drm);
0378
0379     return ret;
0380 }
0381
0382 static int mxsfb_remove(struct platform_device *pdev)
0383 {
0384     struct drm_device *drm = platform_get_drvdata(pdev);
0385
0386     drm_dev_unregister(drm);
0387     drm_atomic_helper_shutdown(drm);
0388     mxsfb_unload(drm);
0389     drm_dev_put(drm);
0390
0391     return 0;
0392 }
0393
0394 static void mxsfb_shutdown(struct platform_device *pdev)
0395 {
0396     struct drm_device *drm = platform_get_drvdata(pdev);
0397
0398     drm_atomic_helper_shutdown(drm);
0399 }
0400
0401 #ifdef CONFIG_PM_SLEEP
0402 static int mxsfb_suspend(struct device *dev)
0403 {
0404     struct drm_device *drm = dev_get_drvdata(dev);
0405
0406     return drm_mode_config_helper_suspend(drm);
0407 }
0408
0409 static int mxsfb_resume(struct device *dev)
0410 {
0411     struct drm_device *drm = dev_get_drvdata(dev);
0412
0413     return drm_mode_config_helper_resume(drm);
0414 }
0415 #endif
0416
0417 static const struct dev_pm_ops mxsfb_pm_ops = {
0418     SET_SYSTEM_SLEEP_PM_OPS(mxsfb_suspend, mxsfb_resume)
0419 };
0420
0421 static struct platform_driver mxsfb_platform_driver = {
0422     .probe      = mxsfb_probe,
0423     .remove     = mxsfb_remove,
0424     .shutdown   = mxsfb_shutdown,
0425     .driver = {
0426         .name       = "mxsfb",
0427         .of_match_table = mxsfb_dt_ids,
0428         .pm     = &mxsfb_pm_ops,
0429     },
0430 };
0431
0432 drm_module_platform_driver(mxsfb_platform_driver);
0433
0434 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
0435 MODULE_DESCRIPTION("Freescale MXS DRM/KMS driver");
0436 MODULE_LICENSE("GPL");