Merge tag 'vmwgfx-next-160520' of git://people.freedesktop.org/~thomash/linux into drm-next

Pull request of 2016-05-20

* tag 'vmwgfx-next-160520' of git://people.freedesktop.org/~thomash/linux:
  drm/vmwgfx: Report vmwgfx version to vmware.log
  drm/vmwgfx: Add VMWare host messaging capability
  drm/vmwgfx: Kill some lockdep warnings

8 files changed, 653 insertions, 16 deletions

diff --git a/drivers/gpu/drm/vmwgfx/Makefile b/drivers/gpu/drm/vmwgfx/Makefile
index d281575bbe11..473d00451b0f 100644
--- a/drivers/gpu/drm/vmwgfx/Makefile
+++ b/drivers/gpu/drm/vmwgfx/Makefile
@@ -8,6 +8,6 @@ vmwgfx-y := vmwgfx_execbuf.o vmwgfx_gmr.o vmwgfx_kms.o vmwgfx_drv.o \
             vmwgfx_fence.o vmwgfx_dmabuf.o vmwgfx_scrn.o vmwgfx_context.o \
             vmwgfx_surface.o vmwgfx_prime.o vmwgfx_mob.o vmwgfx_shader.o \
             vmwgfx_cmdbuf_res.o vmwgfx_cmdbuf.o vmwgfx_stdu.o \
-            vmwgfx_cotable.o vmwgfx_so.o vmwgfx_binding.o
+            vmwgfx_cotable.o vmwgfx_so.o vmwgfx_binding.o vmwgfx_msg.o
 
 obj-$(CONFIG_DRM_VMWGFX) := vmwgfx.o
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index 9555e204814a..9fcd8200d485 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -1,6 +1,6 @@
 /**************************************************************************
  *
- * Copyright © 2009-2015 VMware, Inc., Palo Alto, CA., USA
+ * Copyright © 2009-2016 VMware, Inc., Palo Alto, CA., USA
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -44,6 +44,12 @@
 #define VMW_MIN_INITIAL_WIDTH 800
 #define VMW_MIN_INITIAL_HEIGHT 600
 
+#ifndef VMWGFX_GIT_VERSION
+#define VMWGFX_GIT_VERSION "Unknown"
+#endif
+
+#define VMWGFX_REPO "In Tree"
+
 
 /**
  * Fully encoded drm commands. Might move to vmw_drm.h
@@ -613,6 +619,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         uint32_t svga_id;
         enum vmw_res_type i;
         bool refuse_dma = false;
+        char host_log[100] = {0};
 
         dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);
         if (unlikely(dev_priv == NULL)) {
@@ -628,6 +635,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         mutex_init(&dev_priv->cmdbuf_mutex);
         mutex_init(&dev_priv->release_mutex);
         mutex_init(&dev_priv->binding_mutex);
+        mutex_init(&dev_priv->global_kms_state_mutex);
         rwlock_init(&dev_priv->resource_lock);
         ttm_lock_init(&dev_priv->reservation_sem);
         spin_lock_init(&dev_priv->hw_lock);
@@ -873,6 +881,16 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
 
         DRM_INFO("DX: %s\n", dev_priv->has_dx ? "yes." : "no.");
 
+        snprintf(host_log, sizeof(host_log), "vmwgfx: %s-%s",
+                VMWGFX_REPO, VMWGFX_GIT_VERSION);
+        vmw_host_log(host_log);
+
+        memset(host_log, 0, sizeof(host_log));
+        snprintf(host_log, sizeof(host_log), "vmwgfx: Module Version: %d.%d.%d",
+                VMWGFX_DRIVER_MAJOR, VMWGFX_DRIVER_MINOR,
+                VMWGFX_DRIVER_PATCHLEVEL);
+        vmw_host_log(host_log);
+
         if (dev_priv->enable_fb) {
                 vmw_fifo_resource_inc(dev_priv);
                 vmw_svga_enable(dev_priv);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index 019a6ca3e8e9..1980e2a28265 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -412,6 +412,7 @@ struct vmw_private {
         struct drm_property *implicit_placement_property;
         unsigned num_implicit;
         struct vmw_framebuffer *implicit_fb;
+        struct mutex global_kms_state_mutex;
 
         /*
          * Context and surface management.
@@ -1234,4 +1235,10 @@ static inline void vmw_mmio_write(u32 value, u32 *addr)
 {
         WRITE_ONCE(*addr, value);
 }
+
+/**
+ * Add vmw_msg module function
+ */
+extern int vmw_host_log(const char *log);
+
 #endif
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index fc20d45e3da9..55231cce73a0 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -2143,13 +2143,13 @@ int vmw_kms_fbdev_init_data(struct vmw_private *dev_priv,
 void vmw_kms_del_active(struct vmw_private *dev_priv,
                         struct vmw_display_unit *du)
 {
-        lockdep_assert_held_once(&dev_priv->dev->mode_config.mutex);
-
+        mutex_lock(&dev_priv->global_kms_state_mutex);
         if (du->active_implicit) {
                 if (--(dev_priv->num_implicit) == 0)
                         dev_priv->implicit_fb = NULL;
                 du->active_implicit = false;
         }
+        mutex_unlock(&dev_priv->global_kms_state_mutex);
 }
 
 /**
@@ -2165,8 +2165,7 @@ void vmw_kms_add_active(struct vmw_private *dev_priv,
                         struct vmw_display_unit *du,
                         struct vmw_framebuffer *vfb)
 {
-        lockdep_assert_held_once(&dev_priv->dev->mode_config.mutex);
-
+        mutex_lock(&dev_priv->global_kms_state_mutex);
         WARN_ON_ONCE(!dev_priv->num_implicit && dev_priv->implicit_fb);
 
         if (!du->active_implicit && du->is_implicit) {
@@ -2174,6 +2173,7 @@ void vmw_kms_add_active(struct vmw_private *dev_priv,
                 du->active_implicit = true;
                 dev_priv->num_implicit++;
         }
+        mutex_unlock(&dev_priv->global_kms_state_mutex);
 }
 
 /**
@@ -2190,16 +2190,13 @@ bool vmw_kms_crtc_flippable(struct vmw_private *dev_priv,
                             struct drm_crtc *crtc)
 {
         struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
+        bool ret;
 
-        lockdep_assert_held_once(&dev_priv->dev->mode_config.mutex);
-
-        if (!du->is_implicit)
-                return true;
-
-        if (dev_priv->num_implicit != 1)
-                return false;
+        mutex_lock(&dev_priv->global_kms_state_mutex);
+        ret = !du->is_implicit || dev_priv->num_implicit == 1;
+        mutex_unlock(&dev_priv->global_kms_state_mutex);
 
-        return true;
+        return ret;
 }
 
 /**
@@ -2214,16 +2211,18 @@ void vmw_kms_update_implicit_fb(struct vmw_private *dev_priv,
         struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
         struct vmw_framebuffer *vfb;
 
-        lockdep_assert_held_once(&dev_priv->dev->mode_config.mutex);
+        mutex_lock(&dev_priv->global_kms_state_mutex);
 
         if (!du->is_implicit)
-                return;
+                goto out_unlock;
 
         vfb = vmw_framebuffer_to_vfb(crtc->primary->fb);
         WARN_ON_ONCE(dev_priv->num_implicit != 1 &&
                      dev_priv->implicit_fb != vfb);
 
         dev_priv->implicit_fb = vfb;
+out_unlock:
+        mutex_unlock(&dev_priv->global_kms_state_mutex);
 }
 
 /**
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_msg.c b/drivers/gpu/drm/vmwgfx/vmwgfx_msg.c
new file mode 100644
index 000000000000..6de283c8fa3e
--- /dev/null
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_msg.c
@@ -0,0 +1,416 @@
+/*
+ * Copyright © 2016 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <asm/hypervisor.h>
+#include "drmP.h"
+#include "vmwgfx_msg.h"
+
+
+#define MESSAGE_STATUS_SUCCESS  0x0001
+#define MESSAGE_STATUS_DORECV   0x0002
+#define MESSAGE_STATUS_CPT      0x0010
+#define MESSAGE_STATUS_HB       0x0080
+
+#define RPCI_PROTOCOL_NUM       0x49435052
+#define GUESTMSG_FLAG_COOKIE    0x80000000
+
+#define RETRIES                 3
+
+#define VMW_HYPERVISOR_MAGIC    0x564D5868
+#define VMW_HYPERVISOR_PORT     0x5658
+#define VMW_HYPERVISOR_HB_PORT  0x5659
+
+#define VMW_PORT_CMD_MSG        30
+#define VMW_PORT_CMD_HB_MSG     0
+#define VMW_PORT_CMD_OPEN_CHANNEL  (MSG_TYPE_OPEN << 16 | VMW_PORT_CMD_MSG)
+#define VMW_PORT_CMD_CLOSE_CHANNEL (MSG_TYPE_CLOSE << 16 | VMW_PORT_CMD_MSG)
+#define VMW_PORT_CMD_SENDSIZE   (MSG_TYPE_SENDSIZE << 16 | VMW_PORT_CMD_MSG)
+#define VMW_PORT_CMD_RECVSIZE   (MSG_TYPE_RECVSIZE << 16 | VMW_PORT_CMD_MSG)
+#define VMW_PORT_CMD_RECVSTATUS (MSG_TYPE_RECVSTATUS << 16 | VMW_PORT_CMD_MSG)
+
+#define HIGH_WORD(X) ((X & 0xFFFF0000) >> 16)
+
+static u32 vmw_msg_enabled = 1;
+
+enum rpc_msg_type {
+        MSG_TYPE_OPEN,
+        MSG_TYPE_SENDSIZE,
+        MSG_TYPE_SENDPAYLOAD,
+        MSG_TYPE_RECVSIZE,
+        MSG_TYPE_RECVPAYLOAD,
+        MSG_TYPE_RECVSTATUS,
+        MSG_TYPE_CLOSE,
+};
+
+struct rpc_channel {
+        u16 channel_id;
+        u32 cookie_high;
+        u32 cookie_low;
+};
+
+
+
+/**
+ * vmw_open_channel
+ *
+ * @channel: RPC channel
+ * @protocol:
+ *
+ * Returns: 0 on success
+ */
+static int vmw_open_channel(struct rpc_channel *channel, unsigned int protocol)
+{
+        unsigned long eax, ebx, ecx, edx, si = 0, di = 0;
+
+        VMW_PORT(VMW_PORT_CMD_OPEN_CHANNEL,
+                (protocol | GUESTMSG_FLAG_COOKIE), si, di,
+                VMW_HYPERVISOR_PORT,
+                VMW_HYPERVISOR_MAGIC,
+                eax, ebx, ecx, edx, si, di);
+
+        if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0)
+                return -EINVAL;
+
+        channel->channel_id  = HIGH_WORD(edx);
+        channel->cookie_high = si;
+        channel->cookie_low  = di;
+
+        return 0;
+}
+
+
+
+/**
+ * vmw_close_channel
+ *
+ * @channel: RPC channel
+ *
+ * Returns: 0 on success
+ */
+static int vmw_close_channel(struct rpc_channel *channel)
+{
+        unsigned long eax, ebx, ecx, edx, si, di;
+
+        /* Set up additional parameters */
+        si  = channel->cookie_high;
+        di  = channel->cookie_low;
+
+        VMW_PORT(VMW_PORT_CMD_CLOSE_CHANNEL,
+                0, si, di,
+                (VMW_HYPERVISOR_PORT | (channel->channel_id << 16)),
+                VMW_HYPERVISOR_MAGIC,
+                eax, ebx, ecx, edx, si, di);
+
+        if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0)
+                return -EINVAL;
+
+        return 0;
+}
+
+
+
+/**
+ * vmw_send_msg: Sends a message to the host
+ *
+ * @channel: RPC channel
+ * @logmsg: NULL terminated string
+ *
+ * Returns: 0 on success
+ */
+static int vmw_send_msg(struct rpc_channel *channel, const char *msg)
+{
+        unsigned long eax, ebx, ecx, edx, si, di, bp;
+        size_t msg_len = strlen(msg);
+        int retries = 0;
+
+
+        while (retries < RETRIES) {
+                retries++;
+
+                /* Set up additional parameters */
+                si  = channel->cookie_high;
+                di  = channel->cookie_low;
+
+                VMW_PORT(VMW_PORT_CMD_SENDSIZE,
+                        msg_len, si, di,
+                        VMW_HYPERVISOR_PORT | (channel->channel_id << 16),
+                        VMW_HYPERVISOR_MAGIC,
+                        eax, ebx, ecx, edx, si, di);
+
+                if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0 ||
+                    (HIGH_WORD(ecx) & MESSAGE_STATUS_HB) == 0) {
+                        /* Expected success + high-bandwidth. Give up. */
+                        return -EINVAL;
+                }
+
+                /* Send msg */
+                si  = (uintptr_t) msg;
+                di  = channel->cookie_low;
+                bp  = channel->cookie_high;
+
+                VMW_PORT_HB_OUT(
+                        (MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG,
+                        msg_len, si, di,
+                        VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16),
+                        VMW_HYPERVISOR_MAGIC, bp,
+                        eax, ebx, ecx, edx, si, di);
+
+                if ((HIGH_WORD(ebx) & MESSAGE_STATUS_SUCCESS) != 0) {
+                        return 0;
+                } else if ((HIGH_WORD(ebx) & MESSAGE_STATUS_CPT) != 0) {
+                        /* A checkpoint occurred. Retry. */
+                        continue;
+                } else {
+                        break;
+                }
+        }
+
+        return -EINVAL;
+}
+
+
+
+/**
+ * vmw_recv_msg: Receives a message from the host
+ *
+ * Note:  It is the caller's responsibility to call kfree() on msg.
+ *
+ * @channel:  channel opened by vmw_open_channel
+ * @msg:  [OUT] message received from the host
+ * @msg_len: message length
+ */
+static int vmw_recv_msg(struct rpc_channel *channel, void **msg,
+                        size_t *msg_len)
+{
+        unsigned long eax, ebx, ecx, edx, si, di, bp;
+        char *reply;
+        size_t reply_len;
+        int retries = 0;
+
+
+        *msg_len = 0;
+        *msg = NULL;
+
+        while (retries < RETRIES) {
+                retries++;
+
+                /* Set up additional parameters */
+                si  = channel->cookie_high;
+                di  = channel->cookie_low;
+
+                VMW_PORT(VMW_PORT_CMD_RECVSIZE,
+                        0, si, di,
+                        (VMW_HYPERVISOR_PORT | (channel->channel_id << 16)),
+                        VMW_HYPERVISOR_MAGIC,
+                        eax, ebx, ecx, edx, si, di);
+
+                if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0 ||
+                    (HIGH_WORD(ecx) & MESSAGE_STATUS_HB) == 0) {
+                        DRM_ERROR("Failed to get reply size\n");
+                        return -EINVAL;
+                }
+
+                /* No reply available.  This is okay. */
+                if ((HIGH_WORD(ecx) & MESSAGE_STATUS_DORECV) == 0)
+                        return 0;
+
+                reply_len = ebx;
+                reply     = kzalloc(reply_len + 1, GFP_KERNEL);
+                if (reply == NULL) {
+                        DRM_ERROR("Cannot allocate memory for reply\n");
+                        return -ENOMEM;
+                }
+
+
+                /* Receive buffer */
+                si  = channel->cookie_high;
+                di  = (uintptr_t) reply;
+                bp  = channel->cookie_low;
+
+                VMW_PORT_HB_IN(
+                        (MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG,
+                        reply_len, si, di,
+                        VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16),
+                        VMW_HYPERVISOR_MAGIC, bp,
+                        eax, ebx, ecx, edx, si, di);
+
+                if ((HIGH_WORD(ebx) & MESSAGE_STATUS_SUCCESS) == 0) {
+                        kfree(reply);
+
+                        if ((HIGH_WORD(ebx) & MESSAGE_STATUS_CPT) != 0) {
+                                /* A checkpoint occurred. Retry. */
+                                continue;
+                        }
+
+                        return -EINVAL;
+                }
+
+                reply[reply_len] = '\0';
+
+
+                /* Ack buffer */
+                si  = channel->cookie_high;
+                di  = channel->cookie_low;
+
+                VMW_PORT(VMW_PORT_CMD_RECVSTATUS,
+                        MESSAGE_STATUS_SUCCESS, si, di,
+                        (VMW_HYPERVISOR_PORT | (channel->channel_id << 16)),
+                        VMW_HYPERVISOR_MAGIC,
+                        eax, ebx, ecx, edx, si, di);
+
+                if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0) {
+                        kfree(reply);
+
+                        if ((HIGH_WORD(ecx) & MESSAGE_STATUS_CPT) != 0) {
+                                /* A checkpoint occurred. Retry. */
+                                continue;
+                        }
+
+                        return -EINVAL;
+                }
+
+                break;
+        }
+
+        *msg_len = reply_len;
+        *msg     = reply;
+
+        return 0;
+}
+
+
+/**
+ * vmw_host_get_guestinfo: Gets a GuestInfo parameter
+ *
+ * Gets the value of a  GuestInfo.* parameter.  The value returned will be in
+ * a string, and it is up to the caller to post-process.
+ *
+ * @guest_info_param:  Parameter to get, e.g. GuestInfo.svga.gl3
+ * @buffer: if NULL, *reply_len will contain reply size.
+ * @length: size of the reply_buf.  Set to size of reply upon return
+ *
+ * Returns: 0 on success
+ */
+int vmw_host_get_guestinfo(const char *guest_info_param,
+                           char *buffer, size_t *length)
+{
+        struct rpc_channel channel;
+        char *msg, *reply = NULL;
+        size_t msg_len, reply_len = 0;
+        int ret = 0;
+
+
+        if (!vmw_msg_enabled)
+                return -ENODEV;
+
+        if (!guest_info_param || !length)
+                return -EINVAL;
+
+        msg_len = strlen(guest_info_param) + strlen("info-get ") + 1;
+        msg = kzalloc(msg_len, GFP_KERNEL);
+        if (msg == NULL) {
+                DRM_ERROR("Cannot allocate memory to get %s", guest_info_param);
+                return -ENOMEM;
+        }
+
+        sprintf(msg, "info-get %s", guest_info_param);
+
+        if (vmw_open_channel(&channel, RPCI_PROTOCOL_NUM) ||
+            vmw_send_msg(&channel, msg) ||
+            vmw_recv_msg(&channel, (void *) &reply, &reply_len) ||
+            vmw_close_channel(&channel)) {
+                DRM_ERROR("Failed to get %s", guest_info_param);
+
+                ret = -EINVAL;
+        }
+
+        if (buffer && reply && reply_len > 0) {
+                /* Remove reply code, which are the first 2 characters of
+                 * the reply
+                 */
+                reply_len = max(reply_len - 2, (size_t) 0);
+                reply_len = min(reply_len, *length);
+
+                if (reply_len > 0)
+                        memcpy(buffer, reply + 2, reply_len);
+        }
+
+        *length = reply_len;
+
+        kfree(reply);
+        kfree(msg);
+
+        return ret;
+}
+
+
+
+/**
+ * vmw_host_log: Sends a log message to the host
+ *
+ * @log: NULL terminated string
+ *
+ * Returns: 0 on success
+ */
+int vmw_host_log(const char *log)
+{
+        struct rpc_channel channel;
+        char *msg;
+        int msg_len;
+        int ret = 0;
+
+
+        if (!vmw_msg_enabled)
+                return -ENODEV;
+
+        if (!log)
+                return ret;
+
+        msg_len = strlen(log) + strlen("log ") + 1;
+        msg = kzalloc(msg_len, GFP_KERNEL);
+        if (msg == NULL) {
+                DRM_ERROR("Cannot allocate memory for log message\n");
+                return -ENOMEM;
+        }
+
+        sprintf(msg, "log %s", log);
+
+        if (vmw_open_channel(&channel, RPCI_PROTOCOL_NUM) ||
+            vmw_send_msg(&channel, msg) ||
+            vmw_close_channel(&channel)) {
+                DRM_ERROR("Failed to send log\n");
+
+                ret = -EINVAL;
+        }
+
+        kfree(msg);
+
+        return ret;
+}
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_msg.h b/drivers/gpu/drm/vmwgfx/vmwgfx_msg.h
new file mode 100644
index 000000000000..557a033fb610
--- /dev/null
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_msg.h
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2016, VMware, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * Based on code from vmware.c and vmmouse.c.
+ * Author:
+ *   Sinclair Yeh <syeh@vmware.com>
+ */
+#ifndef _VMWGFX_MSG_H
+#define _VMWGFX_MSG_H
+
+
+/**
+ * Hypervisor-specific bi-directional communication channel.  Should never
+ * execute on bare metal hardware.  The caller must make sure to check for
+ * supported hypervisor before using these macros.
+ *
+ * The last two parameters are both input and output and must be initialized.
+ *
+ * @cmd: [IN] Message Cmd
+ * @in_ebx: [IN] Message Len, through EBX
+ * @in_si: [IN] Input argument through SI, set to 0 if not used
+ * @in_di: [IN] Input argument through DI, set ot 0 if not used
+ * @port_num: [IN] port number + [channel id]
+ * @magic: [IN] hypervisor magic value
+ * @eax: [OUT] value of EAX register
+ * @ebx: [OUT] e.g. status from an HB message status command
+ * @ecx: [OUT] e.g. status from a non-HB message status command
+ * @edx: [OUT] e.g. channel id
+ * @si:  [OUT]
+ * @di:  [OUT]
+ */
+#define VMW_PORT(cmd, in_ebx, in_si, in_di,     \
+                 port_num, magic,               \
+                 eax, ebx, ecx, edx, si, di)    \
+({                                              \
+        asm volatile ("inl %%dx, %%eax;" :      \
+                "=a"(eax),                      \
+                "=b"(ebx),                      \
+                "=c"(ecx),                      \
+                "=d"(edx),                      \
+                "=S"(si),                       \
+                "=D"(di) :                      \
+                "a"(magic),                     \
+                "b"(in_ebx),                    \
+                "c"(cmd),                       \
+                "d"(port_num),                  \
+                "S"(in_si),                     \
+                "D"(in_di) :                    \
+                "memory");                      \
+})
+
+
+/**
+ * Hypervisor-specific bi-directional communication channel.  Should never
+ * execute on bare metal hardware.  The caller must make sure to check for
+ * supported hypervisor before using these macros.
+ *
+ * The last 3 parameters are both input and output and must be initialized.
+ *
+ * @cmd: [IN] Message Cmd
+ * @in_ecx: [IN] Message Len, through ECX
+ * @in_si: [IN] Input argument through SI, set to 0 if not used
+ * @in_di: [IN] Input argument through DI, set to 0 if not used
+ * @port_num: [IN] port number + [channel id]
+ * @magic: [IN] hypervisor magic value
+ * @bp:  [IN]
+ * @eax: [OUT] value of EAX register
+ * @ebx: [OUT] e.g. status from an HB message status command
+ * @ecx: [OUT] e.g. status from a non-HB message status command
+ * @edx: [OUT] e.g. channel id
+ * @si:  [OUT]
+ * @di:  [OUT]
+ */
+#ifdef __x86_64__
+
+#define VMW_PORT_HB_OUT(cmd, in_ecx, in_si, in_di,      \
+                        port_num, magic, bp,            \
+                        eax, ebx, ecx, edx, si, di)     \
+({                                                      \
+        asm volatile ("push %%rbp;"                     \
+                "mov %12, %%rbp;"                       \
+                "rep outsb;"                            \
+                "pop %%rbp;" :                          \
+                "=a"(eax),                              \
+                "=b"(ebx),                              \
+                "=c"(ecx),                              \
+                "=d"(edx),                              \
+                "=S"(si),                               \
+                "=D"(di) :                              \
+                "a"(magic),                             \
+                "b"(cmd),                               \
+                "c"(in_ecx),                            \
+                "d"(port_num),                          \
+                "S"(in_si),                             \
+                "D"(in_di),                             \
+                "r"(bp) :                               \
+                "memory", "cc");                        \
+})
+
+
+#define VMW_PORT_HB_IN(cmd, in_ecx, in_si, in_di,       \
+                       port_num, magic, bp,             \
+                       eax, ebx, ecx, edx, si, di)      \
+({                                                      \
+        asm volatile ("push %%rbp;"                     \
+                "mov %12, %%rbp;"                       \
+                "rep insb;"                             \
+                "pop %%rbp" :                           \
+                "=a"(eax),                              \
+                "=b"(ebx),                              \
+                "=c"(ecx),                              \
+                "=d"(edx),                              \
+                "=S"(si),                               \
+                "=D"(di) :                              \
+                "a"(magic),                             \
+                "b"(cmd),                               \
+                "c"(in_ecx),                            \
+                "d"(port_num),                          \
+                "S"(in_si),                             \
+                "D"(in_di),                             \
+                "r"(bp) :                               \
+                "memory", "cc");                        \
+})
+
+#else
+
+/* In the 32-bit version of this macro, we use "m" because there is no
+ * more register left for bp
+ */
+#define VMW_PORT_HB_OUT(cmd, in_ecx, in_si, in_di,      \
+                        port_num, magic, bp,            \
+                        eax, ebx, ecx, edx, si, di)     \
+({                                                      \
+        asm volatile ("push %%ebp;"                     \
+                "mov %12, %%ebp;"                       \
+                "rep outsb;"                            \
+                "pop %%ebp;" :                          \
+                "=a"(eax),                              \
+                "=b"(ebx),                              \
+                "=c"(ecx),                              \
+                "=d"(edx),                              \
+                "=S"(si),                               \
+                "=D"(di) :                              \
+                "a"(magic),                             \
+                "b"(cmd),                               \
+                "c"(in_ecx),                            \
+                "d"(port_num),                          \
+                "S"(in_si),                             \
+                "D"(in_di),                             \
+                "m"(bp) :                               \
+                "memory", "cc");                        \
+})
+
+
+#define VMW_PORT_HB_IN(cmd, in_ecx, in_si, in_di,       \
+                       port_num, magic, bp,             \
+                       eax, ebx, ecx, edx, si, di)      \
+({                                                      \
+        asm volatile ("push %%ebp;"                     \
+                "mov %12, %%ebp;"                       \
+                "rep insb;"                             \
+                "pop %%ebp" :                           \
+                "=a"(eax),                              \
+                "=b"(ebx),                              \
+                "=c"(ecx),                              \
+                "=d"(edx),                              \
+                "=S"(si),                               \
+                "=D"(di) :                              \
+                "a"(magic),                             \
+                "b"(cmd),                               \
+                "c"(in_ecx),                            \
+                "d"(port_num),                          \
+                "S"(in_si),                             \
+                "D"(in_di),                             \
+                "m"(bp) :                               \
+                "memory", "cc");                        \
+})
+#endif /* #if __x86_64__ */
+
+#endif
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
index 0ea22fd112c9..b74eae2b8594 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
@@ -285,14 +285,17 @@ static int vmw_sou_crtc_set_config(struct drm_mode_set *set)
         }
 
         /* Only one active implicit frame-buffer at a time. */
+        mutex_lock(&dev_priv->global_kms_state_mutex);
         if (sou->base.is_implicit &&
             dev_priv->implicit_fb && vfb &&
             !(dev_priv->num_implicit == 1 &&
               sou->base.active_implicit) &&
             dev_priv->implicit_fb != vfb) {
+                mutex_unlock(&dev_priv->global_kms_state_mutex);
                 DRM_ERROR("Multiple implicit framebuffers not supported.\n");
                 return -EINVAL;
         }
+        mutex_unlock(&dev_priv->global_kms_state_mutex);
 
         /* since they always map one to one these are safe */
         connector = &sou->base.connector;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
index b949102ad864..9ca818fb034c 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
@@ -553,12 +553,15 @@ static int vmw_stdu_crtc_set_config(struct drm_mode_set *set)
         }
 
         /* Only one active implicit frame-buffer at a time. */
+        mutex_lock(&dev_priv->global_kms_state_mutex);
         if (!turning_off && stdu->base.is_implicit && dev_priv->implicit_fb &&
             !(dev_priv->num_implicit == 1 && stdu->base.active_implicit)
             && dev_priv->implicit_fb != vfb) {
+                mutex_unlock(&dev_priv->global_kms_state_mutex);
                 DRM_ERROR("Multiple implicit framebuffers not supported.\n");
                 return -EINVAL;
         }
+        mutex_unlock(&dev_priv->global_kms_state_mutex);
 
         /* Since they always map one to one these are safe */
         connector = &stdu->base.connector;