Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 208 insertions, 49 deletions

diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 96e963108225..09292193dafe 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -30,7 +30,6 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/i2c.h>
-#include <linux/i2c-algo-bit.h>
 #include "drmP.h"
 #include "drm_edid.h"
 #include "drm_edid_modes.h"
@@ -185,9 +184,9 @@ drm_edid_block_valid(u8 *raw_edid)
 
 bad:
         if (raw_edid) {
-                DRM_ERROR("Raw EDID:\n");
+                printk(KERN_ERR "Raw EDID:\n");
                 print_hex_dump_bytes(KERN_ERR, DUMP_PREFIX_NONE, raw_edid, EDID_LENGTH);
-                printk("\n");
+                printk(KERN_ERR "\n");
         }
         return 0;
 }
@@ -231,30 +230,49 @@ drm_do_probe_ddc_edid(struct i2c_adapter *adapter, unsigned char *buf,
                       int block, int len)
 {
         unsigned char start = block * EDID_LENGTH;
-        struct i2c_msg msgs[] = {
-                {
-                        .addr   = DDC_ADDR,
-                        .flags  = 0,
-                        .len    = 1,
-                        .buf    = &start,
-                }, {
-                        .addr   = DDC_ADDR,
-                        .flags  = I2C_M_RD,
-                        .len    = len,
-                        .buf    = buf + start,
-                }
-        };
+        int ret, retries = 5;
 
-        if (i2c_transfer(adapter, msgs, 2) == 2)
-                return 0;
+        /* The core i2c driver will automatically retry the transfer if the
+         * adapter reports EAGAIN. However, we find that bit-banging transfers
+         * are susceptible to errors under a heavily loaded machine and
+         * generate spurious NAKs and timeouts. Retrying the transfer
+         * of the individual block a few times seems to overcome this.
+         */
+        do {
+                struct i2c_msg msgs[] = {
+                        {
+                                .addr   = DDC_ADDR,
+                                .flags  = 0,
+                                .len    = 1,
+                                .buf    = &start,
+                        }, {
+                                .addr   = DDC_ADDR,
+                                .flags  = I2C_M_RD,
+                                .len    = len,
+                                .buf    = buf,
+                        }
+                };
+                ret = i2c_transfer(adapter, msgs, 2);
+        } while (ret != 2 && --retries);
+
+        return ret == 2 ? 0 : -1;
+}
+
+static bool drm_edid_is_zero(u8 *in_edid, int length)
+{
+        int i;
+        u32 *raw_edid = (u32 *)in_edid;
 
-        return -1;
+        for (i = 0; i < length / 4; i++)
+                if (*(raw_edid + i) != 0)
+                        return false;
+        return true;
 }
 
 static u8 *
 drm_do_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter)
 {
-        int i, j = 0;
+        int i, j = 0, valid_extensions = 0;
         u8 *block, *new;
 
         if ((block = kmalloc(EDID_LENGTH, GFP_KERNEL)) == NULL)
@@ -266,6 +284,10 @@ drm_do_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter)
                         goto out;
                 if (drm_edid_block_valid(block))
                         break;
+                if (i == 0 && drm_edid_is_zero(block, EDID_LENGTH)) {
+                        connector->null_edid_counter++;
+                        goto carp;
+                }
         }
         if (i == 4)
                 goto carp;
@@ -281,14 +303,28 @@ drm_do_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter)
 
         for (j = 1; j <= block[0x7e]; j++) {
                 for (i = 0; i < 4; i++) {
-                        if (drm_do_probe_ddc_edid(adapter, block, j,
-                                                  EDID_LENGTH))
+                        if (drm_do_probe_ddc_edid(adapter,
+                                  block + (valid_extensions + 1) * EDID_LENGTH,
+                                  j, EDID_LENGTH))
                                 goto out;
-                        if (drm_edid_block_valid(block + j * EDID_LENGTH))
+                        if (drm_edid_block_valid(block + (valid_extensions + 1) * EDID_LENGTH)) {
+                                valid_extensions++;
                                 break;
+                        }
                 }
                 if (i == 4)
-                        goto carp;
+                        dev_warn(connector->dev->dev,
+                         "%s: Ignoring invalid EDID block %d.\n",
+                         drm_get_connector_name(connector), j);
+        }
+
+        if (valid_extensions != block[0x7e]) {
+                block[EDID_LENGTH-1] += block[0x7e] - valid_extensions;
+                block[0x7e] = valid_extensions;
+                new = krealloc(block, (valid_extensions + 1) * EDID_LENGTH, GFP_KERNEL);
+                if (!new)
+                        goto out;
+                block = new;
         }
 
         return block;
@@ -436,12 +472,11 @@ static void edid_fixup_preferred(struct drm_connector *connector,
 struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
                                            int hsize, int vsize, int fresh)
 {
+        struct drm_display_mode *mode = NULL;
         int i;
-        struct drm_display_mode *ptr, *mode;
 
-        mode = NULL;
         for (i = 0; i < drm_num_dmt_modes; i++) {
-                ptr = &drm_dmt_modes[i];
+                const struct drm_display_mode *ptr = &drm_dmt_modes[i];
                 if (hsize == ptr->hdisplay &&
                         vsize == ptr->vdisplay &&
                         fresh == drm_mode_vrefresh(ptr)) {
@@ -872,7 +907,7 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
 }
 
 static bool
-mode_is_rb(struct drm_display_mode *mode)
+mode_is_rb(const struct drm_display_mode *mode)
 {
         return (mode->htotal - mode->hdisplay == 160) &&
                (mode->hsync_end - mode->hdisplay == 80) &&
@@ -881,7 +916,8 @@ mode_is_rb(struct drm_display_mode *mode)
 }
 
 static bool
-mode_in_hsync_range(struct drm_display_mode *mode, struct edid *edid, u8 *t)
+mode_in_hsync_range(const struct drm_display_mode *mode,
+                    struct edid *edid, u8 *t)
 {
         int hsync, hmin, hmax;
 
@@ -897,7 +933,8 @@ mode_in_hsync_range(struct drm_display_mode *mode, struct edid *edid, u8 *t)
 }
 
 static bool
-mode_in_vsync_range(struct drm_display_mode *mode, struct edid *edid, u8 *t)
+mode_in_vsync_range(const struct drm_display_mode *mode,
+                    struct edid *edid, u8 *t)
 {
         int vsync, vmin, vmax;
 
@@ -928,7 +965,7 @@ range_pixel_clock(struct edid *edid, u8 *t)
 }
 
 static bool
-mode_in_range(struct drm_display_mode *mode, struct edid *edid,
+mode_in_range(const struct drm_display_mode *mode, struct edid *edid,
               struct detailed_timing *timing)
 {
         u32 max_clock;
@@ -1268,34 +1305,52 @@ add_detailed_modes(struct drm_connector *connector, struct edid *edid,
 }
 
 #define HDMI_IDENTIFIER 0x000C03
+#define AUDIO_BLOCK     0x01
 #define VENDOR_BLOCK    0x03
+#define EDID_BASIC_AUDIO        (1 << 6)
+
 /**
- * drm_detect_hdmi_monitor - detect whether monitor is hdmi.
- * @edid: monitor EDID information
- *
- * Parse the CEA extension according to CEA-861-B.
- * Return true if HDMI, false if not or unknown.
+ * Search EDID for CEA extension block.
  */
-bool drm_detect_hdmi_monitor(struct edid *edid)
+u8 *drm_find_cea_extension(struct edid *edid)
 {
-        char *edid_ext = NULL;
-        int i, hdmi_id;
-        int start_offset, end_offset;
-        bool is_hdmi = false;
+        u8 *edid_ext = NULL;
+        int i;
 
         /* No EDID or EDID extensions */
         if (edid == NULL || edid->extensions == 0)
-                goto end;
+                return NULL;
 
         /* Find CEA extension */
         for (i = 0; i < edid->extensions; i++) {
-                edid_ext = (char *)edid + EDID_LENGTH * (i + 1);
-                /* This block is CEA extension */
-                if (edid_ext[0] == 0x02)
+                edid_ext = (u8 *)edid + EDID_LENGTH * (i + 1);
+                if (edid_ext[0] == CEA_EXT)
                         break;
         }
 
         if (i == edid->extensions)
+                return NULL;
+
+        return edid_ext;
+}
+EXPORT_SYMBOL(drm_find_cea_extension);
+
+/**
+ * drm_detect_hdmi_monitor - detect whether monitor is hdmi.
+ * @edid: monitor EDID information
+ *
+ * Parse the CEA extension according to CEA-861-B.
+ * Return true if HDMI, false if not or unknown.
+ */
+bool drm_detect_hdmi_monitor(struct edid *edid)
+{
+        u8 *edid_ext;
+        int i, hdmi_id;
+        int start_offset, end_offset;
+        bool is_hdmi = false;
+
+        edid_ext = drm_find_cea_extension(edid);
+        if (!edid_ext)
                 goto end;
 
         /* Data block offset in CEA extension block */
@@ -1326,6 +1381,111 @@ end:
 EXPORT_SYMBOL(drm_detect_hdmi_monitor);
 
 /**
+ * drm_detect_monitor_audio - check monitor audio capability
+ *
+ * Monitor should have CEA extension block.
+ * If monitor has 'basic audio', but no CEA audio blocks, it's 'basic
+ * audio' only. If there is any audio extension block and supported
+ * audio format, assume at least 'basic audio' support, even if 'basic
+ * audio' is not defined in EDID.
+ *
+ */
+bool drm_detect_monitor_audio(struct edid *edid)
+{
+        u8 *edid_ext;
+        int i, j;
+        bool has_audio = false;
+        int start_offset, end_offset;
+
+        edid_ext = drm_find_cea_extension(edid);
+        if (!edid_ext)
+                goto end;
+
+        has_audio = ((edid_ext[3] & EDID_BASIC_AUDIO) != 0);
+
+        if (has_audio) {
+                DRM_DEBUG_KMS("Monitor has basic audio support\n");
+                goto end;
+        }
+
+        /* Data block offset in CEA extension block */
+        start_offset = 4;
+        end_offset = edid_ext[2];
+
+        for (i = start_offset; i < end_offset;
+                        i += ((edid_ext[i] & 0x1f) + 1)) {
+                if ((edid_ext[i] >> 5) == AUDIO_BLOCK) {
+                        has_audio = true;
+                        for (j = 1; j < (edid_ext[i] & 0x1f); j += 3)
+                                DRM_DEBUG_KMS("CEA audio format %d\n",
+                                              (edid_ext[i + j] >> 3) & 0xf);
+                        goto end;
+                }
+        }
+end:
+        return has_audio;
+}
+EXPORT_SYMBOL(drm_detect_monitor_audio);
+
+/**
+ * drm_add_display_info - pull display info out if present
+ * @edid: EDID data
+ * @info: display info (attached to connector)
+ *
+ * Grab any available display info and stuff it into the drm_display_info
+ * structure that's part of the connector.  Useful for tracking bpp and
+ * color spaces.
+ */
+static void drm_add_display_info(struct edid *edid,
+                                 struct drm_display_info *info)
+{
+        info->width_mm = edid->width_cm * 10;
+        info->height_mm = edid->height_cm * 10;
+
+        /* driver figures it out in this case */
+        info->bpc = 0;
+        info->color_formats = 0;
+
+        /* Only defined for 1.4 with digital displays */
+        if (edid->revision < 4)
+                return;
+
+        if (!(edid->input & DRM_EDID_INPUT_DIGITAL))
+                return;
+
+        switch (edid->input & DRM_EDID_DIGITAL_DEPTH_MASK) {
+        case DRM_EDID_DIGITAL_DEPTH_6:
+                info->bpc = 6;
+                break;
+        case DRM_EDID_DIGITAL_DEPTH_8:
+                info->bpc = 8;
+                break;
+        case DRM_EDID_DIGITAL_DEPTH_10:
+                info->bpc = 10;
+                break;
+        case DRM_EDID_DIGITAL_DEPTH_12:
+                info->bpc = 12;
+                break;
+        case DRM_EDID_DIGITAL_DEPTH_14:
+                info->bpc = 14;
+                break;
+        case DRM_EDID_DIGITAL_DEPTH_16:
+                info->bpc = 16;
+                break;
+        case DRM_EDID_DIGITAL_DEPTH_UNDEF:
+        default:
+                info->bpc = 0;
+                break;
+        }
+
+        info->color_formats = DRM_COLOR_FORMAT_RGB444;
+        if (info->color_formats & DRM_EDID_FEATURE_RGB_YCRCB444)
+                info->color_formats = DRM_COLOR_FORMAT_YCRCB444;
+        if (info->color_formats & DRM_EDID_FEATURE_RGB_YCRCB422)
+                info->color_formats = DRM_COLOR_FORMAT_YCRCB422;
+}
+
+/**
  * drm_add_edid_modes - add modes from EDID data, if available
  * @connector: connector we're probing
  * @edid: edid data
@@ -1373,8 +1533,7 @@ int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
         if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75))
                 edid_fixup_preferred(connector, quirks);
 
-        connector->display_info.width_mm = edid->width_cm * 10;
-        connector->display_info.height_mm = edid->height_cm * 10;
+        drm_add_display_info(edid, &connector->display_info);
 
         return num_modes;
 }
@@ -1395,7 +1554,7 @@ int drm_add_modes_noedid(struct drm_connector *connector,
                         int hdisplay, int vdisplay)
 {
         int i, count, num_modes = 0;
-        struct drm_display_mode *mode, *ptr;
+        struct drm_display_mode *mode;
         struct drm_device *dev = connector->dev;
 
         count = sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
@@ -1405,7 +1564,7 @@ int drm_add_modes_noedid(struct drm_connector *connector,
                 vdisplay = 0;
 
         for (i = 0; i < count; i++) {
-                ptr = &drm_dmt_modes[i];
+                const struct drm_display_mode *ptr = &drm_dmt_modes[i];
                 if (hdisplay && vdisplay) {
                         /*
                          * Only when two are valid, they will be used to check