Commit 147a0907 authored by Patrik Jakobsson's avatar Patrik Jakobsson
Browse files

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: default avatarPatrik Jakobsson <patrik.r.jakobsson@gmail.com>
Acked-by: default avatarThomas Zimmermann <tzimmermann@suse.de>
Link: https://patchwork.freedesktop.org/patch/msgid/20220601092311.22648-6-patrik.r.jakobsson@gmail.com
parent 544ef140

drivers/gpu/drm/gma500/psb_intel_lvds.c

+37 −35
Original line number Diff line number Diff line
@@ -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,

	/* 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);

					  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 @@ void psb_intel_lvds_init(struct drm_device *dev, 
	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);

}