Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

[karo-tx-linux.git] / drivers / gpu / drm / gma500 / cdv_intel_lvds.c

diff --git a/drivers/gpu/drm/gma500/cdv_intel_lvds.c b/drivers/gpu/drm/gma500/cdv_intel_lvds.c
index d81dbc3368f0116a19da89c6b03d7b8c5371a83d..20e08e65d46ccfecdf06dd03c150347c14c0f327 100644 (file)
--- a/drivers/gpu/drm/gma500/cdv_intel_lvds.c
+++ b/drivers/gpu/drm/gma500/cdv_intel_lvds.c
@@ -356,8 +356,7 @@ static void cdv_intel_lvds_mode_set(struct drm_encoder *encoder,
 {
        struct drm_device *dev = encoder->dev;
        struct drm_psb_private *dev_priv = dev->dev_private;
-       struct psb_intel_crtc *psb_intel_crtc = to_psb_intel_crtc(
-                                                       encoder->crtc);
+       struct gma_crtc *gma_crtc = to_gma_crtc(encoder->crtc);
        u32 pfit_control;
 
        /*
@@ -379,7 +378,7 @@ static void cdv_intel_lvds_mode_set(struct drm_encoder *encoder,
        else
                pfit_control = 0;
 
-       pfit_control |= psb_intel_crtc->pipe << PFIT_PIPE_SHIFT;
+       pfit_control |= gma_crtc->pipe << PFIT_PIPE_SHIFT;
 
        if (dev_priv->lvds_dither)
                pfit_control |= PANEL_8TO6_DITHER_ENABLE;
@@ -407,12 +406,11 @@ static int cdv_intel_lvds_get_modes(struct drm_connector *connector)
 {
        struct drm_device *dev = connector->dev;
        struct drm_psb_private *dev_priv = dev->dev_private;
-       struct psb_intel_encoder *psb_intel_encoder =
-                                       psb_intel_attached_encoder(connector);
+       struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
        struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
        int ret;
 
-       ret = psb_intel_ddc_get_modes(connector, &psb_intel_encoder->i2c_bus->adapter);
+       ret = psb_intel_ddc_get_modes(connector, &gma_encoder->i2c_bus->adapter);
 
        if (ret)
                return ret;
@@ -444,11 +442,10 @@ static int cdv_intel_lvds_get_modes(struct drm_connector *connector)
  */
 static void cdv_intel_lvds_destroy(struct drm_connector *connector)
 {
-       struct psb_intel_encoder *psb_intel_encoder =
-                                       psb_intel_attached_encoder(connector);
+       struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
 
-       if (psb_intel_encoder->i2c_bus)
-               psb_intel_i2c_destroy(psb_intel_encoder->i2c_bus);
+       if (gma_encoder->i2c_bus)
+               psb_intel_i2c_destroy(gma_encoder->i2c_bus);
        drm_sysfs_connector_remove(connector);
        drm_connector_cleanup(connector);
        kfree(connector);
@@ -461,8 +458,7 @@ static int cdv_intel_lvds_set_property(struct drm_connector *connector,
        struct drm_encoder *encoder = connector->encoder;
 
        if (!strcmp(property->name, "scaling mode") && encoder) {
-               struct psb_intel_crtc *crtc =
-                                       to_psb_intel_crtc(encoder->crtc);
+               struct gma_crtc *crtc = to_gma_crtc(encoder->crtc);
                uint64_t curValue;
 
                if (!crtc)
@@ -529,7 +525,7 @@ static const struct drm_connector_helper_funcs
                                cdv_intel_lvds_connector_helper_funcs = {
        .get_modes = cdv_intel_lvds_get_modes,
        .mode_valid = cdv_intel_lvds_mode_valid,
-       .best_encoder = psb_intel_best_encoder,
+       .best_encoder = gma_best_encoder,
 };
 
 static const struct drm_connector_funcs cdv_intel_lvds_connector_funcs = {
@@ -612,8 +608,8 @@ static bool lvds_is_present_in_vbt(struct drm_device *dev,
 void cdv_intel_lvds_init(struct drm_device *dev,
                     struct psb_intel_mode_device *mode_dev)
 {
-       struct psb_intel_encoder *psb_intel_encoder;
-       struct psb_intel_connector *psb_intel_connector;
+       struct gma_encoder *gma_encoder;
+       struct gma_connector *gma_connector;
        struct cdv_intel_lvds_priv *lvds_priv;
        struct drm_connector *connector;
        struct drm_encoder *encoder;
@@ -630,24 +626,24 @@ void cdv_intel_lvds_init(struct drm_device *dev,
                return;
        }
 
-       psb_intel_encoder = kzalloc(sizeof(struct psb_intel_encoder),
+       gma_encoder = kzalloc(sizeof(struct gma_encoder),
                                    GFP_KERNEL);
-       if (!psb_intel_encoder)
+       if (!gma_encoder)
                return;
 
-       psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector),
+       gma_connector = kzalloc(sizeof(struct gma_connector),
                                      GFP_KERNEL);
-       if (!psb_intel_connector)
+       if (!gma_connector)
                goto failed_connector;
 
        lvds_priv = kzalloc(sizeof(struct cdv_intel_lvds_priv), GFP_KERNEL);
        if (!lvds_priv)
                goto failed_lvds_priv;
 
-       psb_intel_encoder->dev_priv = lvds_priv;
+       gma_encoder->dev_priv = lvds_priv;
 
-       connector = &psb_intel_connector->base;
-       encoder = &psb_intel_encoder->base;
+       connector = &gma_connector->base;
+       encoder = &gma_encoder->base;
 
 
        drm_connector_init(dev, connector,
@@ -659,9 +655,8 @@ void cdv_intel_lvds_init(struct drm_device *dev,
                         DRM_MODE_ENCODER_LVDS);
 
 
-       psb_intel_connector_attach_encoder(psb_intel_connector,
-                                          psb_intel_encoder);
-       psb_intel_encoder->type = INTEL_OUTPUT_LVDS;
+       gma_connector_attach_encoder(gma_connector, gma_encoder);
+       gma_encoder->type = INTEL_OUTPUT_LVDS;
 
        drm_encoder_helper_add(encoder, &cdv_intel_lvds_helper_funcs);
        drm_connector_helper_add(connector,
@@ -682,16 +677,16 @@ void cdv_intel_lvds_init(struct drm_device *dev,
         * Set up I2C bus
         * FIXME: distroy i2c_bus when exit
         */
-       psb_intel_encoder->i2c_bus = psb_intel_i2c_create(dev,
+       gma_encoder->i2c_bus = psb_intel_i2c_create(dev,
                                                         GPIOB,
                                                         "LVDSBLC_B");
-       if (!psb_intel_encoder->i2c_bus) {
+       if (!gma_encoder->i2c_bus) {
                dev_printk(KERN_ERR,
                        &dev->pdev->dev, "I2C bus registration failed.\n");
                goto failed_blc_i2c;
        }
-       psb_intel_encoder->i2c_bus->slave_addr = 0x2C;
-       dev_priv->lvds_i2c_bus = psb_intel_encoder->i2c_bus;
+       gma_encoder->i2c_bus->slave_addr = 0x2C;
+       dev_priv->lvds_i2c_bus = gma_encoder->i2c_bus;
 
        /*
         * LVDS discovery:
@@ -704,10 +699,10 @@ void cdv_intel_lvds_init(struct drm_device *dev,
         */
 
        /* Set up the DDC bus. */
-       psb_intel_encoder->ddc_bus = psb_intel_i2c_create(dev,
+       gma_encoder->ddc_bus = psb_intel_i2c_create(dev,
                                                         GPIOC,
                                                         "LVDSDDC_C");
-       if (!psb_intel_encoder->ddc_bus) {
+       if (!gma_encoder->ddc_bus) {
                dev_printk(KERN_ERR, &dev->pdev->dev,
                           "DDC bus registration " "failed.\n");
                goto failed_ddc;
@@ -718,7 +713,7 @@ void cdv_intel_lvds_init(struct drm_device *dev,
         * preferred mode is the right one.
         */
        psb_intel_ddc_get_modes(connector,
-                               &psb_intel_encoder->ddc_bus->adapter);
+                               &gma_encoder->ddc_bus->adapter);
        list_for_each_entry(scan, &connector->probed_modes, head) {
                if (scan->type & DRM_MODE_TYPE_PREFERRED) {
                        mode_dev->panel_fixed_mode =
@@ -782,19 +777,19 @@ out:
 
 failed_find:
        printk(KERN_ERR "Failed find\n");
-       if (psb_intel_encoder->ddc_bus)
-               psb_intel_i2c_destroy(psb_intel_encoder->ddc_bus);
+       if (gma_encoder->ddc_bus)
+               psb_intel_i2c_destroy(gma_encoder->ddc_bus);
 failed_ddc:
        printk(KERN_ERR "Failed DDC\n");
-       if (psb_intel_encoder->i2c_bus)
-               psb_intel_i2c_destroy(psb_intel_encoder->i2c_bus);
+       if (gma_encoder->i2c_bus)
+               psb_intel_i2c_destroy(gma_encoder->i2c_bus);
 failed_blc_i2c:
        printk(KERN_ERR "Failed BLC\n");
        drm_encoder_cleanup(encoder);
        drm_connector_cleanup(connector);
        kfree(lvds_priv);
 failed_lvds_priv:
-       kfree(psb_intel_connector);
+       kfree(gma_connector);
 failed_connector:
-       kfree(psb_intel_encoder);
+       kfree(gma_encoder);
 }