[Graphic] Add hdmi settings operation, user can select to set

disable/enable hdmi panel, resolution, scan type and overscan
compensation

BZ: 26899

User can select to set disable/enable HDMI panel(default enable),
resolution based on edid, scan type(center, aspect and full) and
overscan compensation.

Change-Id: I2b2504d3ece61169a8c5c832e9ff2240246ce8d9
Signed-off-by: ljia5 <lin.a.jia@intel.com>
Reviewed-on: http://android.intel.com:8080/46682
Reviewed-by: Tong, BoX <box.tong@intel.com>
Tested-by: Tong, BoX <box.tong@intel.com>
Reviewed-by: buildbot <buildbot@intel.com>
Tested-by: buildbot <buildbot@intel.com>

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
old mode 100644 (file)
new mode 100755 (executable)
index 1707198..85a4a77
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -2481,6 +2481,10 @@ int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
                                found = 1;
                                break;
                        }
+                       if(property == connector->dev->mode_config.scaling_mode_property) {
+                               found = 1;
+                               break;
+                       }
                }
                if (!found) {
                        goto out;

diff --git a/drivers/staging/mrst/drv/psb_intel_display2.c b/drivers/staging/mrst/drv/psb_intel_display2.c
old mode 100644 (file)
new mode 100755 (executable)
index 3c300fe..c86c56a
--- a/drivers/staging/mrst/drv/psb_intel_display2.c
+++ b/drivers/staging/mrst/drv/psb_intel_display2.c
@@ -649,12 +649,19 @@ static int mdfld_intel_set_scaling_property(struct drm_crtc *crtc, int x, int y,
        struct drm_framebuffer *fb = crtc->fb;
        struct drm_display_mode *adjusted_mode = & psb_intel_crtc->saved_adjusted_mode;
        uint64_t scalingType = psb_intel_crtc->scaling_type;
+       uint64_t scalingStep = psb_intel_crtc->scaling_step;
+       static uint64_t lastScalingStep = -1;
+       static int landscape = -1, last_landscape =-1;
+       static int last_src_image_hor = 0, last_src_image_vert = 0;
+       static int horScalingCount = 0;
+       static int vertScalingCount = 0;
        int pipesrc_reg = PIPEASRC;
        int dspsize_reg = DSPASIZE;
        int dsppos_reg = DSPAPOS;
        int sprite_pos_x = 0, sprite_pos_y = 0;
        int sprite_width = 0, sprite_height = 0;
        int src_image_hor = 0, src_image_vert = 0;
+       int hValue=-1, vValue=-1;
 
        switch (pipe) {
         case 0:
@@ -686,6 +693,25 @@ static int mdfld_intel_set_scaling_property(struct drm_crtc *crtc, int x, int y,
                sprite_width = MIN(fb->width, adjusted_mode->hdisplay);
                sprite_height = MIN(fb->height, adjusted_mode->vdisplay);
 
+               PSB_DEBUG_ENTRY("fb->width:%d,fb->height:%d,adjusted_mode->hdisplay:%d,adjusted_mode->vdisplay:%d\n", fb->width,fb->height,adjusted_mode->hdisplay,adjusted_mode->vdisplay);
+
+               if ((last_src_image_hor == 0) && (last_src_image_vert == 0)) {
+                       last_src_image_hor = adjusted_mode->hdisplay;
+                       last_src_image_vert = adjusted_mode->vdisplay;
+               }
+
+               hValue = (scalingStep&0xF0)>>4;
+               vValue = (scalingStep&0xF00)>>8;
+
+               PSB_DEBUG_ENTRY("last_src_image_hor %d, last_src_image_vert %d \n", last_src_image_hor, last_src_image_vert);
+
+               if((last_src_image_hor != adjusted_mode->hdisplay)
+                       &&(last_src_image_vert != adjusted_mode->vdisplay)){
+                       psb_intel_crtc->scaling_step =0;
+                       scalingStep =0;
+               }
+               PSB_DEBUG_ENTRY("scalingType %llu, scalingStep ox%x, hValue %d, vValue %d \n", scalingType, scalingStep, hValue, vValue);
+
                switch (scalingType) {
                case DRM_MODE_SCALE_NONE:
                case DRM_MODE_SCALE_CENTER:
@@ -794,12 +820,79 @@ static int mdfld_intel_set_scaling_property(struct drm_crtc *crtc, int x, int y,
                        break;
                }
 
-               PSB_DEBUG_ENTRY("Sprite position: (%d, %d)\n", sprite_pos_x,
+               if (scalingStep != 0)
+               {
+                       u32 sprite_pos, sprite_size, src_size;
+
+                       if(fb->width > fb->height)
+                               landscape = 0;
+                       if(fb->width < fb->height)
+                               landscape = 1;
+
+                       if ((last_landscape == -1)
+                               ||(last_landscape == landscape))
+                       {
+                               horScalingCount = hValue;
+                               vertScalingCount = vValue;
+
+                               PSB_DEBUG_ENTRY("Before: Sprite position: (%d, %d)\n", sprite_pos_x,
+                                       sprite_pos_y);
+                               PSB_DEBUG_ENTRY("Before: Sprite size: %d x %d\n", sprite_width,
+                                       sprite_height);
+                               PSB_DEBUG_ENTRY("Before: Pipe source image size: %d x %d\n",
+                                       src_image_hor, src_image_vert);
+                               PSB_DEBUG_ENTRY("hValue %d, vValue %d \n", hValue, vValue);
+                               if (!((fb->width < fb->height) &&(scalingType == DRM_MODE_SCALE_ASPECT)))
+                               {
+                                       if (hValue !=0) {
+                                               sprite_pos_x = sprite_pos_x + (adjusted_mode->hdisplay* hValue)/100;
+                                               src_image_hor = src_image_hor + (adjusted_mode->hdisplay*hValue*2)/100;
+                                       }
+                               }
+
+                               if (vValue!=0) {
+                                       sprite_pos_y = sprite_pos_y + (adjusted_mode->vdisplay*vValue)/100;
+                                       src_image_vert = src_image_vert + (adjusted_mode->vdisplay*vValue*2)/100;
+                               }
+
+                               if ((hValue == -1)||(vValue==-1))
+                                       psb_intel_crtc->scaling_step = 0;
+
+                               last_landscape = landscape;
+                       }
+
+                       if (last_landscape != landscape) {
+                               if (!((fb->width < fb->height) &&(scalingType == DRM_MODE_SCALE_ASPECT))){
+                                       sprite_pos_x = sprite_pos_x + (adjusted_mode->hdisplay* horScalingCount)/100;
+                                       src_image_hor = src_image_hor + (adjusted_mode->hdisplay*horScalingCount*2)/100;
+                               }
+
+                               sprite_pos_y = sprite_pos_y + (adjusted_mode->vdisplay*vertScalingCount)/100;
+                               src_image_vert = src_image_vert + (adjusted_mode->vdisplay*vertScalingCount*2)/100;
+
+                               last_landscape = landscape;
+                       }
+               }
+
+               if(scalingStep == 0) {
+                       horScalingCount = 0;
+                       vertScalingCount = 0;
+                       last_landscape = -1;
+                       hValue =-1;
+                       vValue =-1;
+               }
+
+               last_src_image_hor = adjusted_mode->hdisplay;
+               last_src_image_vert = adjusted_mode->vdisplay;
+
+               PSB_DEBUG_ENTRY("After: Sprite position: (%d, %d)\n", sprite_pos_x,
                                sprite_pos_y);
-               PSB_DEBUG_ENTRY("Sprite size: %d x %d\n", sprite_width,
+               PSB_DEBUG_ENTRY("After: Sprite size: %d x %d\n", sprite_width,
                                sprite_height);
-               PSB_DEBUG_ENTRY("Pipe source image size: %d x %d\n",
+               PSB_DEBUG_ENTRY("After: Pipe source image size: %d x %d\n",
                                src_image_hor, src_image_vert);
+               PSB_DEBUG_ENTRY(" Adjust mode size: %d x %d\n",
+                               adjusted_mode->hdisplay, adjusted_mode->vdisplay);
 
                REG_WRITE(dsppos_reg, (sprite_pos_y << 16) | sprite_pos_x);
                REG_WRITE(dspsize_reg, ((sprite_height - 1) << 16) |
@@ -1981,7 +2074,18 @@ static int mdfld_crtc_mode_set(struct drm_crtc *crtc,
                drm_connector_property_get_value(&psb_intel_output->base,
                        dev->mode_config.scaling_mode_property, &scalingType);
 
-       psb_intel_crtc->scaling_type = scalingType;
+       if ((scalingType == DRM_MODE_SCALE_NO_SCALE)
+               ||(scalingType < DRM_MODE_SCALE_NO_SCALE))
+       {
+               psb_intel_crtc->scaling_type = scalingType;
+               psb_intel_crtc->scaling_step = 0;
+       }
+       else
+       {
+               psb_intel_crtc->scaling_step = scalingType;
+               if (drm_connector_property_set_value(&psb_intel_output->base,dev->mode_config.scaling_mode_property,psb_intel_crtc->scaling_type))
+                       return -EINVAL;
+       }
 
        if (scalingType == DRM_MODE_SCALE_NO_SCALE) {
                /*Moorestown doesn't have register support for centering so we need to

diff --git a/drivers/staging/mrst/drv/psb_intel_drv.h b/drivers/staging/mrst/drv/psb_intel_drv.h
old mode 100644 (file)
new mode 100755 (executable)
index 0729cff..e58e09a
--- a/drivers/staging/mrst/drv/psb_intel_drv.h
+++ b/drivers/staging/mrst/drv/psb_intel_drv.h
@@ -194,6 +194,7 @@ struct psb_intel_crtc {
 
        /* crtc scaling type */
        u32 scaling_type;
+       u32 scaling_step;
 
 /*FIXME: Workaround to avoid MRST block.*/
 #ifndef CONFIG_X86_MDFLD

diff --git a/drivers/staging/mrst/drv/psb_intel_hdmi.c b/drivers/staging/mrst/drv/psb_intel_hdmi.c
index db7229f..d80510c 100644 (file)
--- a/drivers/staging/mrst/drv/psb_intel_hdmi.c
+++ b/drivers/staging/mrst/drv/psb_intel_hdmi.c
@@ -1328,6 +1328,10 @@ mdfld_hdmi_edid_detect(struct drm_connector *connector)
        int i = 0;
        int ret = 0;
        int monitor_number = sizeof(mdfld_hdmi_edid) / sizeof(struct hdmi_edid_info);
+       static u8 last_mfg_id[2] = {0,0};
+       static u8 last_prod_code[2] = {0,0};
+       static u32 last_serial = 0; /* FIXME: byte order */
+       int hdmi_change = 0;
 
        PSB_DEBUG_ENTRY("\n");
 
@@ -1356,6 +1360,29 @@ mdfld_hdmi_edid_detect(struct drm_connector *connector)
                        hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
                        mdfld_hdmi_create_eeld_packet(connector);
                }
+
+               if(hdmi_change == 0)
+               {
+                       if (!(((edid->mfg_id[0] == last_mfg_id[0])&&(edid->mfg_id[1] == last_mfg_id[1]))
+                               &&((edid->prod_code[0] == last_prod_code[0])&&(edid->prod_code[1] == last_prod_code[1]))
+                               &&(edid->serial == last_serial))) {
+                               hdmi_change = 1;
+                       }
+                               last_mfg_id[0] = edid->mfg_id[0];
+                               last_mfg_id[1] = edid->mfg_id[1];
+                               last_prod_code[0] = edid->prod_code[0];
+                               last_prod_code[1] = edid->prod_code[1];
+                               last_serial = edid->serial;
+               }
+               if (hdmi_change ==1) {
+                       drm_connector_property_set_value(connector,dev->mode_config.scaling_mode_property,DRM_MODE_SCALE_ASPECT);
+               }
+
+               DRM_INFO("hdmi_change =%d", hdmi_change);
+               DRM_INFO("mfg_id: 0x%x,0x%x", edid->mfg_id[0],edid->mfg_id[1]);
+               DRM_INFO("prod_code: 0x%x,0x%x", edid->prod_code[0],edid->prod_code[1]);
+               DRM_INFO("serial: 0x%x", edid->serial);
+
                drm_mode_connector_update_edid_property(connector, edid);
                kfree(edid);
                dev_priv->hdmi_done_reading_edid = true;
@@ -1563,25 +1590,9 @@ static int mdfld_hdmi_set_property(struct drm_connector *connector,
                if (!pPsbCrtc)
                        goto set_prop_error;
 
-               switch (value) {
-               case DRM_MODE_SCALE_FULLSCREEN:
-                       break;
-               case DRM_MODE_SCALE_CENTER:
-                       break;
-               case DRM_MODE_SCALE_NO_SCALE:
-                       break;
-               case DRM_MODE_SCALE_ASPECT:
-                       break;
-               default:
-                       goto set_prop_error;
-               }
-
                if (drm_connector_property_get_value(connector, property, &curValue))
                        goto set_prop_error;
 
-               if (curValue == value)
-                       goto set_prop_done;
-
                if (drm_connector_property_set_value(connector, property, value))
                        goto set_prop_error;
 
@@ -1592,7 +1603,8 @@ static int mdfld_hdmi_set_property(struct drm_connector *connector,
 
                if (pPsbCrtc->saved_mode.hdisplay != 0 &&
                    pPsbCrtc->saved_mode.vdisplay != 0) {
-                       if (bTransitionFromToCentered || bTransitionFromToAspect) {
+                       if (bTransitionFromToCentered || bTransitionFromToAspect
+                               ||(value > DRM_MODE_SCALE_NO_SCALE) || (value == DRM_MODE_SCALE_FULLSCREEN)){
                                if (!drm_crtc_helper_set_mode(pEncoder->crtc, &pPsbCrtc->saved_mode,
                                            pEncoder->crtc->x, pEncoder->crtc->y, pEncoder->crtc->fb))
                                        goto set_prop_error;