Merge tag 'drm-msm-next-2023-10-17' of https://gitlab.freedesktop.org/drm/msm into...

Updates for v6.7

DP:
- use existing helpers for DPCD handling instead of open-coded functions
- set the subconnector type according to the plugged cable / dongle
  skip validity check for DP CTS EDID checksum

DPU:
- continued migration of feature flags to use core revision checks
- reworked interrupts code to use '0' as NO_IRQ, removed raw IRQ indices
  from log / trace output

gpu:
- a7xx support (a730, a740)
- fixes and additional speedbins for a635, a643

core:
- decouple msm_drv from kms to more cleanly support headless devices (like
  imx5+a2xx)

From: Rob Clark <robdclark@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/CAF6AEGvzkBL2_OgyOeP_b6rVEjrNdfm8jcKzaB04HqHyT5jYwA@mail.gmail.com
Signed-off-by: Dave Airlie <airlied@redhat.com>

diff --cc drivers/gpu/drm/msm/adreno/adreno_device.c
Simple merge

diff --cc drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c
index 82381d12414d82a27b12eda72ecce4e4924abf96,d14ae316796c8bda25c808a52df259999f0e0d66..fe7267b3bff536fb80d5197249b3d55c1b55d73e
--- 1/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c
--- 2/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c
@@@ -1299,12 -1230,72 +1230,70 @@@ static int dpu_kms_init(struct drm_devi
  
  static int dpu_dev_probe(struct platform_device *pdev)
  {
-       return msm_drv_probe(&pdev->dev, dpu_kms_init);
+       struct device *dev = &pdev->dev;
+       struct dpu_kms *dpu_kms;
+       int irq;
+       int ret = 0;
+ 
+       dpu_kms = devm_kzalloc(dev, sizeof(*dpu_kms), GFP_KERNEL);
+       if (!dpu_kms)
+               return -ENOMEM;
+ 
+       dpu_kms->pdev = pdev;
+ 
+       ret = devm_pm_opp_set_clkname(dev, "core");
+       if (ret)
+               return ret;
+       /* OPP table is optional */
+       ret = devm_pm_opp_of_add_table(dev);
+       if (ret && ret != -ENODEV)
+               return dev_err_probe(dev, ret, "invalid OPP table in device tree\n");
+ 
+       ret = devm_clk_bulk_get_all(&pdev->dev, &dpu_kms->clocks);
+       if (ret < 0)
+               return dev_err_probe(dev, ret, "failed to parse clocks\n");
+ 
+       dpu_kms->num_clocks = ret;
+ 
+       irq = platform_get_irq(pdev, 0);
+       if (irq < 0)
+               return dev_err_probe(dev, irq, "failed to get irq\n");
+ 
+       dpu_kms->base.irq = irq;
+ 
+       dpu_kms->mmio = msm_ioremap(pdev, "mdp");
+       if (IS_ERR(dpu_kms->mmio)) {
+               ret = PTR_ERR(dpu_kms->mmio);
+               DPU_ERROR("mdp register memory map failed: %d\n", ret);
+               dpu_kms->mmio = NULL;
+               return ret;
+       }
+       DRM_DEBUG("mapped dpu address space @%pK\n", dpu_kms->mmio);
+ 
+       dpu_kms->vbif[VBIF_RT] = msm_ioremap(pdev, "vbif");
+       if (IS_ERR(dpu_kms->vbif[VBIF_RT])) {
+               ret = PTR_ERR(dpu_kms->vbif[VBIF_RT]);
+               DPU_ERROR("vbif register memory map failed: %d\n", ret);
+               dpu_kms->vbif[VBIF_RT] = NULL;
+               return ret;
+       }
+ 
+       dpu_kms->vbif[VBIF_NRT] = msm_ioremap_quiet(pdev, "vbif_nrt");
+       if (IS_ERR(dpu_kms->vbif[VBIF_NRT])) {
+               dpu_kms->vbif[VBIF_NRT] = NULL;
+               DPU_DEBUG("VBIF NRT is not defined");
+       }
+ 
+       ret = dpu_kms_parse_data_bus_icc_path(dpu_kms);
+       if (ret)
+               return ret;
+ 
+       return msm_drv_probe(&pdev->dev, dpu_kms_init, &dpu_kms->base);
  }
  
 -static int dpu_dev_remove(struct platform_device *pdev)
 +static void dpu_dev_remove(struct platform_device *pdev)
  {
        component_master_del(&pdev->dev, &msm_drm_ops);
 -
 -      return 0;
  }
  
  static int __maybe_unused dpu_runtime_suspend(struct device *dev)
@@@ -1380,8 -1371,8 +1369,8 @@@ MODULE_DEVICE_TABLE(of, dpu_dt_match)
  
  static struct platform_driver dpu_driver = {
        .probe = dpu_dev_probe,
 -      .remove = dpu_dev_remove,
 +      .remove_new = dpu_dev_remove,
-       .shutdown = msm_drv_shutdown,
+       .shutdown = msm_kms_shutdown,
        .driver = {
                .name = "msm_dpu",
                .of_match_table = dpu_dt_match,

diff --cc drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c
index e5012fa6771fc6b27e7d9d6e12d9b595bc3eefe9,982b7689e5b6377d5b3a596b29e468f567bb19dd..4ba1cb74ad7600e0f59f954471c4e9c468537ba5
--- 1/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c
--- 2/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c
+++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c
@@@ -557,12 -507,60 +507,58 @@@ static const struct dev_pm_ops mdp4_pm_
  
  static int mdp4_probe(struct platform_device *pdev)
  {
-       return msm_drv_probe(&pdev->dev, mdp4_kms_init);
+       struct device *dev = &pdev->dev;
+       struct mdp4_kms *mdp4_kms;
+       int irq;
+ 
+       mdp4_kms = devm_kzalloc(dev, sizeof(*mdp4_kms), GFP_KERNEL);
+       if (!mdp4_kms)
+               return dev_err_probe(dev, -ENOMEM, "failed to allocate kms\n");
+ 
+       mdp4_kms->mmio = msm_ioremap(pdev, NULL);
+       if (IS_ERR(mdp4_kms->mmio))
+               return PTR_ERR(mdp4_kms->mmio);
+ 
+       irq = platform_get_irq(pdev, 0);
+       if (irq < 0)
+               return dev_err_probe(dev, irq, "failed to get irq\n");
+ 
+       mdp4_kms->base.base.irq = irq;
+ 
+       /* NOTE: driver for this regulator still missing upstream.. use
+        * _get_exclusive() and ignore the error if it does not exist
+        * (and hope that the bootloader left it on for us)
+        */
+       mdp4_kms->vdd = devm_regulator_get_exclusive(&pdev->dev, "vdd");
+       if (IS_ERR(mdp4_kms->vdd))
+               mdp4_kms->vdd = NULL;
+ 
+       mdp4_kms->clk = devm_clk_get(&pdev->dev, "core_clk");
+       if (IS_ERR(mdp4_kms->clk))
+               return dev_err_probe(dev, PTR_ERR(mdp4_kms->clk), "failed to get core_clk\n");
+ 
+       mdp4_kms->pclk = devm_clk_get(&pdev->dev, "iface_clk");
+       if (IS_ERR(mdp4_kms->pclk))
+               mdp4_kms->pclk = NULL;
+ 
+       mdp4_kms->axi_clk = devm_clk_get(&pdev->dev, "bus_clk");
+       if (IS_ERR(mdp4_kms->axi_clk))
+               return dev_err_probe(dev, PTR_ERR(mdp4_kms->axi_clk), "failed to get axi_clk\n");
+ 
+       /*
+        * This is required for revn >= 2. Handle errors here and let the kms
+        * init bail out if the clock is not provided.
+        */
+       mdp4_kms->lut_clk = devm_clk_get_optional(&pdev->dev, "lut_clk");
+       if (IS_ERR(mdp4_kms->lut_clk))
+               return dev_err_probe(dev, PTR_ERR(mdp4_kms->lut_clk), "failed to get lut_clk\n");
+ 
+       return msm_drv_probe(&pdev->dev, mdp4_kms_init, &mdp4_kms->base.base);
  }
  
 -static int mdp4_remove(struct platform_device *pdev)
 +static void mdp4_remove(struct platform_device *pdev)
  {
        component_master_del(&pdev->dev, &msm_drm_ops);
 -
 -      return 0;
  }
  
  static const struct of_device_id mdp4_dt_match[] = {
@@@ -573,8 -571,8 +569,8 @@@ MODULE_DEVICE_TABLE(of, mdp4_dt_match)
  
  static struct platform_driver mdp4_platform_driver = {
        .probe      = mdp4_probe,
 -      .remove     = mdp4_remove,
 +      .remove_new = mdp4_remove,
-       .shutdown   = msm_drv_shutdown,
+       .shutdown   = msm_kms_shutdown,
        .driver     = {
                .name   = "mdp4",
                .of_match_table = mdp4_dt_match,

diff --cc drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c
index 8a7b44376bc68c89fb6d39b17c0b44dfd5e06599,a28fbcd0968422e6053deaeb14d72e36767a2a2b..11d9fc2c6bf5e07845a43e40035d0b39f9810350
--- 1/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c
--- 2/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c
+++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c
@@@ -939,10 -894,43 +894,43 @@@ static int mdp5_dev_probe(struct platfo
        if (ret)
                return ret;
  
-       return msm_drv_probe(&pdev->dev, mdp5_kms_init);
+       mdp5_kms->pdev = pdev;
+ 
+       spin_lock_init(&mdp5_kms->resource_lock);
+ 
+       mdp5_kms->mmio = msm_ioremap(pdev, "mdp_phys");
+       if (IS_ERR(mdp5_kms->mmio))
+               return PTR_ERR(mdp5_kms->mmio);
+ 
+       /* mandatory clocks: */
+       ret = get_clk(pdev, &mdp5_kms->axi_clk, "bus", true);
+       if (ret)
+               return ret;
+       ret = get_clk(pdev, &mdp5_kms->ahb_clk, "iface", true);
+       if (ret)
+               return ret;
+       ret = get_clk(pdev, &mdp5_kms->core_clk, "core", true);
+       if (ret)
+               return ret;
+       ret = get_clk(pdev, &mdp5_kms->vsync_clk, "vsync", true);
+       if (ret)
+               return ret;
+ 
+       /* optional clocks: */
+       get_clk(pdev, &mdp5_kms->lut_clk, "lut", false);
+       get_clk(pdev, &mdp5_kms->tbu_clk, "tbu", false);
+       get_clk(pdev, &mdp5_kms->tbu_rt_clk, "tbu_rt", false);
+ 
+       irq = platform_get_irq(pdev, 0);
+       if (irq < 0)
+               return dev_err_probe(&pdev->dev, irq, "failed to get irq\n");
+ 
+       mdp5_kms->base.base.irq = irq;
+ 
+       return msm_drv_probe(&pdev->dev, mdp5_kms_init, &mdp5_kms->base.base);
  }
  
 -static int mdp5_dev_remove(struct platform_device *pdev)
 +static void mdp5_dev_remove(struct platform_device *pdev)
  {
        DBG("");
        component_master_del(&pdev->dev, &msm_drm_ops);
@@@ -986,8 -975,8 +974,8 @@@ MODULE_DEVICE_TABLE(of, mdp5_dt_match)
  
  static struct platform_driver mdp5_driver = {
        .probe = mdp5_dev_probe,
 -      .remove = mdp5_dev_remove,
 +      .remove_new = mdp5_dev_remove,
-       .shutdown = msm_drv_shutdown,
+       .shutdown = msm_kms_shutdown,
        .driver = {
                .name = "msm_mdp",
                .of_match_table = mdp5_dt_match,

diff --cc drivers/gpu/drm/msm/dp/dp_display.c
Simple merge

diff --cc drivers/gpu/drm/msm/dsi/dsi.c
Simple merge

diff --cc drivers/gpu/drm/msm/hdmi/hdmi.c
Simple merge

diff --cc drivers/gpu/drm/msm/msm_drv.c
index a428951ee5399e9a732b41a98558baf85076c6d3,b61ccea0532765680eeed5225a16b74db07d3a3b..443bbc3ed75089110ef9f17f014e99be5209ff60
--- 1/drivers/gpu/drm/msm/msm_drv.c
--- 2/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@@ -1275,37 -972,21 +972,19 @@@ int msm_drv_probe(struct device *master
  
  static int msm_pdev_probe(struct platform_device *pdev)
  {
-       return msm_drv_probe(&pdev->dev, NULL);
+       return msm_drv_probe(&pdev->dev, NULL, NULL);
  }
  
 -static int msm_pdev_remove(struct platform_device *pdev)
 +static void msm_pdev_remove(struct platform_device *pdev)
  {
        component_master_del(&pdev->dev, &msm_drm_ops);
 -
 -      return 0;
  }
  
- void msm_drv_shutdown(struct platform_device *pdev)
- {
-       struct msm_drm_private *priv = platform_get_drvdata(pdev);
-       struct drm_device *drm = priv ? priv->dev : NULL;
- 
-       /*
-        * Shutdown the hw if we're far enough along where things might be on.
-        * If we run this too early, we'll end up panicking in any variety of
-        * places. Since we don't register the drm device until late in
-        * msm_drm_init, drm_dev->registered is used as an indicator that the
-        * shutdown will be successful.
-        */
-       if (drm && drm->registered && priv->kms)
-               drm_atomic_helper_shutdown(drm);
- }
- 
  static struct platform_driver msm_platform_driver = {
        .probe      = msm_pdev_probe,
 -      .remove     = msm_pdev_remove,
 +      .remove_new = msm_pdev_remove,
-       .shutdown   = msm_drv_shutdown,
        .driver     = {
                .name   = "msm",
-               .pm     = &msm_pm_ops,
        },
  };