drm/gma500: Make psb lvds use ddc adapter from drm_connector

We're moving all uses of ddc_bus to drm_connector where they belong.
Also cleanup the error handling in psb_intel_lvds_init() and remove
unused ddc_bus in psb_intel_lvds_priv.

Signed-off-by: Patrik Jakobsson <patrik.r.jakobsson@gmail.com>
Acked-by: Thomas Zimmermann <tzimmermann@suse.de>
Link: https://patchwork.freedesktop.org/patch/msgid/20220601092311.22648-6-patrik.r.jakobsson@gmail.com

diff --git a/drivers/gpu/drm/gma500/psb_intel_lvds.c b/drivers/gpu/drm/gma500/psb_intel_lvds.c
index c28fabdcfd7350518d40e6b39d6a0e3eacea8747..1121bb155c5ea2981322e7a726ff0f5546450be9 100644 (file)
--- a/drivers/gpu/drm/gma500/psb_intel_lvds.c
+++ b/drivers/gpu/drm/gma500/psb_intel_lvds.c
@@ -50,7 +50,6 @@ struct psb_intel_lvds_priv {
        uint32_t saveBLC_PWM_CTL;
 
        struct gma_i2c_chan *i2c_bus;
-       struct gma_i2c_chan *ddc_bus;
 };
 
 
@@ -512,20 +511,12 @@ static int psb_intel_lvds_get_modes(struct drm_connector *connector)
        return 0;
 }
 
-/**
- * psb_intel_lvds_destroy - unregister and free LVDS structures
- * @connector: connector to free
- *
- * Unregister the DDC bus for this connector then free the driver private
- * structure.
- */
 void psb_intel_lvds_destroy(struct drm_connector *connector)
 {
        struct gma_connector *gma_connector = to_gma_connector(connector);
-       struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
-       struct psb_intel_lvds_priv *lvds_priv = gma_encoder->dev_priv;
+       struct gma_i2c_chan *ddc_bus = to_gma_i2c_chan(connector->ddc);
 
-       gma_i2c_destroy(lvds_priv->ddc_bus);
+       gma_i2c_destroy(ddc_bus);
        drm_connector_cleanup(connector);
        kfree(gma_connector);
 }
@@ -639,25 +630,28 @@ void psb_intel_lvds_init(struct drm_device *dev,
        struct drm_display_mode *scan;  /* *modes, *bios_mode; */
        struct drm_crtc *crtc;
        struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
+       struct gma_i2c_chan *ddc_bus;
        u32 lvds;
        int pipe;
+       int ret;
 
        gma_encoder = kzalloc(sizeof(struct gma_encoder), GFP_KERNEL);
        if (!gma_encoder) {
                dev_err(dev->dev, "gma_encoder allocation error\n");
                return;
        }
+       encoder = &gma_encoder->base;
 
        gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL);
        if (!gma_connector) {
                dev_err(dev->dev, "gma_connector allocation error\n");
-               goto failed_encoder;
+               goto err_free_encoder;
        }
 
        lvds_priv = kzalloc(sizeof(struct psb_intel_lvds_priv), GFP_KERNEL);
        if (!lvds_priv) {
                dev_err(dev->dev, "LVDS private allocation error\n");
-               goto failed_connector;
+               goto err_free_connector;
        }
 
        gma_encoder->dev_priv = lvds_priv;
@@ -666,12 +660,24 @@ void psb_intel_lvds_init(struct drm_device *dev,
        gma_connector->save = psb_intel_lvds_save;
        gma_connector->restore = psb_intel_lvds_restore;
 
-       encoder = &gma_encoder->base;
-       drm_connector_init(dev, connector,
-                          &psb_intel_lvds_connector_funcs,
-                          DRM_MODE_CONNECTOR_LVDS);
+       /* Set up the DDC bus. */
+       ddc_bus = gma_i2c_create(dev, GPIOC, "LVDSDDC_C");
+       if (!ddc_bus) {
+               dev_printk(KERN_ERR, dev->dev,
+                          "DDC bus registration " "failed.\n");
+               goto err_free_lvds_priv;
+       }
+
+       ret = drm_connector_init_with_ddc(dev, connector,
+                                         &psb_intel_lvds_connector_funcs,
+                                         DRM_MODE_CONNECTOR_LVDS,
+                                         &ddc_bus->base);
+       if (ret)
+               goto err_ddc_destroy;
 
-       drm_simple_encoder_init(dev, encoder, DRM_MODE_ENCODER_LVDS);
+       ret = drm_simple_encoder_init(dev, encoder, DRM_MODE_ENCODER_LVDS);
+       if (ret)
+               goto err_connector_cleanup;
 
        gma_connector_attach_encoder(gma_connector, gma_encoder);
        gma_encoder->type = INTEL_OUTPUT_LVDS;
@@ -699,7 +705,7 @@ void psb_intel_lvds_init(struct drm_device *dev,
        if (!lvds_priv->i2c_bus) {
                dev_printk(KERN_ERR,
                        dev->dev, "I2C bus registration failed.\n");
-               goto failed_blc_i2c;
+               goto err_encoder_cleanup;
        }
        lvds_priv->i2c_bus->slave_addr = 0x2C;
        dev_priv->lvds_i2c_bus =  lvds_priv->i2c_bus;
@@ -714,20 +720,13 @@ void psb_intel_lvds_init(struct drm_device *dev,
         *    if closed, act like it's not there for now
         */
 
-       /* Set up the DDC bus. */
-       lvds_priv->ddc_bus = gma_i2c_create(dev, GPIOC, "LVDSDDC_C");
-       if (!lvds_priv->ddc_bus) {
-               dev_printk(KERN_ERR, dev->dev,
-                          "DDC bus registration " "failed.\n");
-               goto failed_ddc;
-       }
-
        /*
         * Attempt to get the fixed panel mode from DDC.  Assume that the
         * preferred mode is the right one.
         */
        mutex_lock(&dev->mode_config.mutex);
-       psb_intel_ddc_get_modes(connector, &lvds_priv->ddc_bus->base);
+       psb_intel_ddc_get_modes(connector, &ddc_bus->base);
+
        list_for_each_entry(scan, &connector->probed_modes, head) {
                if (scan->type & DRM_MODE_TYPE_PREFERRED) {
                        mode_dev->panel_fixed_mode =
@@ -773,7 +772,7 @@ void psb_intel_lvds_init(struct drm_device *dev,
        /* If we still don't have a mode after all that, give up. */
        if (!mode_dev->panel_fixed_mode) {
                dev_err(dev->dev, "Found no modes on the lvds, ignoring the LVDS\n");
-               goto failed_find;
+               goto err_unlock;
        }
 
        /*
@@ -784,17 +783,20 @@ out:
        mutex_unlock(&dev->mode_config.mutex);
        return;
 
-failed_find:
+err_unlock:
        mutex_unlock(&dev->mode_config.mutex);
-       gma_i2c_destroy(lvds_priv->ddc_bus);
-failed_ddc:
        gma_i2c_destroy(lvds_priv->i2c_bus);
-failed_blc_i2c:
+err_encoder_cleanup:
        drm_encoder_cleanup(encoder);
+err_connector_cleanup:
        drm_connector_cleanup(connector);
-failed_connector:
+err_ddc_destroy:
+       gma_i2c_destroy(ddc_bus);
+err_free_lvds_priv:
+       kfree(lvds_priv);
+err_free_connector:
        kfree(gma_connector);
-failed_encoder:
+err_free_encoder:
        kfree(gma_encoder);
 }