drivers/video: add Hyper-V Synthetic Video Frame Buffer Driver

This is the driver for the Hyper-V Synthetic Video, which supports
screen resolution up to Full HD 1920x1080 on Windows Server 2012 host,
and 1600x1200 on Windows Server 2008 R2 or earlier.  It also solves the
double mouse cursor issue of the emulated video mode.

Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com>
Reviewed-by: K. Y. Srinivasan <kys@microsoft.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
Cc: Olaf Hering <olaf@aepfle.de>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 829 insertions, 0 deletions

diff --git a/drivers/video/hyperv_fb.c b/drivers/video/hyperv_fb.c
new file mode 100644
index 000000000000..d4d2c5fe2488
--- /dev/null
+++ b/drivers/video/hyperv_fb.c
@@ -0,0 +1,829 @@
+/*
+ * Copyright (c) 2012, Microsoft Corporation.
+ *
+ * Author:
+ *   Haiyang Zhang <haiyangz@microsoft.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+/*
+ * Hyper-V Synthetic Video Frame Buffer Driver
+ *
+ * This is the driver for the Hyper-V Synthetic Video, which supports
+ * screen resolution up to Full HD 1920x1080 with 32 bit color on Windows
+ * Server 2012, and 1600x1200 with 16 bit color on Windows Server 2008 R2
+ * or earlier.
+ *
+ * It also solves the double mouse cursor issue of the emulated video mode.
+ *
+ * The default screen resolution is 1152x864, which may be changed by a
+ * kernel parameter:
+ *     video=hyperv_fb:<width>x<height>
+ *     For example: video=hyperv_fb:1280x1024
+ *
+ * Portrait orientation is also supported:
+ *     For example: video=hyperv_fb:864x1152
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/completion.h>
+#include <linux/fb.h>
+#include <linux/pci.h>
+
+#include <linux/hyperv.h>
+
+
+/* Hyper-V Synthetic Video Protocol definitions and structures */
+#define MAX_VMBUS_PKT_SIZE 0x4000
+
+#define SYNTHVID_VERSION(major, minor) ((minor) << 16 | (major))
+#define SYNTHVID_VERSION_WIN7 SYNTHVID_VERSION(3, 0)
+#define SYNTHVID_VERSION_WIN8 SYNTHVID_VERSION(3, 2)
+
+#define SYNTHVID_DEPTH_WIN7 16
+#define SYNTHVID_DEPTH_WIN8 32
+
+#define SYNTHVID_FB_SIZE_WIN7 (4 * 1024 * 1024)
+#define SYNTHVID_WIDTH_MAX_WIN7 1600
+#define SYNTHVID_HEIGHT_MAX_WIN7 1200
+
+#define SYNTHVID_FB_SIZE_WIN8 (8 * 1024 * 1024)
+
+#define PCI_VENDOR_ID_MICROSOFT 0x1414
+#define PCI_DEVICE_ID_HYPERV_VIDEO 0x5353
+
+
+enum pipe_msg_type {
+        PIPE_MSG_INVALID,
+        PIPE_MSG_DATA,
+        PIPE_MSG_MAX
+};
+
+struct pipe_msg_hdr {
+        u32 type;
+        u32 size; /* size of message after this field */
+} __packed;
+
+
+enum synthvid_msg_type {
+        SYNTHVID_ERROR                  = 0,
+        SYNTHVID_VERSION_REQUEST        = 1,
+        SYNTHVID_VERSION_RESPONSE       = 2,
+        SYNTHVID_VRAM_LOCATION          = 3,
+        SYNTHVID_VRAM_LOCATION_ACK      = 4,
+        SYNTHVID_SITUATION_UPDATE       = 5,
+        SYNTHVID_SITUATION_UPDATE_ACK   = 6,
+        SYNTHVID_POINTER_POSITION       = 7,
+        SYNTHVID_POINTER_SHAPE          = 8,
+        SYNTHVID_FEATURE_CHANGE         = 9,
+        SYNTHVID_DIRT                   = 10,
+
+        SYNTHVID_MAX                    = 11
+};
+
+struct synthvid_msg_hdr {
+        u32 type;
+        u32 size;  /* size of this header + payload after this field*/
+} __packed;
+
+
+struct synthvid_version_req {
+        u32 version;
+} __packed;
+
+struct synthvid_version_resp {
+        u32 version;
+        u8 is_accepted;
+        u8 max_video_outputs;
+} __packed;
+
+struct synthvid_vram_location {
+        u64 user_ctx;
+        u8 is_vram_gpa_specified;
+        u64 vram_gpa;
+} __packed;
+
+struct synthvid_vram_location_ack {
+        u64 user_ctx;
+} __packed;
+
+struct video_output_situation {
+        u8 active;
+        u32 vram_offset;
+        u8 depth_bits;
+        u32 width_pixels;
+        u32 height_pixels;
+        u32 pitch_bytes;
+} __packed;
+
+struct synthvid_situation_update {
+        u64 user_ctx;
+        u8 video_output_count;
+        struct video_output_situation video_output[1];
+} __packed;
+
+struct synthvid_situation_update_ack {
+        u64 user_ctx;
+} __packed;
+
+struct synthvid_pointer_position {
+        u8 is_visible;
+        u8 video_output;
+        s32 image_x;
+        s32 image_y;
+} __packed;
+
+
+#define CURSOR_MAX_X 96
+#define CURSOR_MAX_Y 96
+#define CURSOR_ARGB_PIXEL_SIZE 4
+#define CURSOR_MAX_SIZE (CURSOR_MAX_X * CURSOR_MAX_Y * CURSOR_ARGB_PIXEL_SIZE)
+#define CURSOR_COMPLETE (-1)
+
+struct synthvid_pointer_shape {
+        u8 part_idx;
+        u8 is_argb;
+        u32 width; /* CURSOR_MAX_X at most */
+        u32 height; /* CURSOR_MAX_Y at most */
+        u32 hot_x; /* hotspot relative to upper-left of pointer image */
+        u32 hot_y;
+        u8 data[4];
+} __packed;
+
+struct synthvid_feature_change {
+        u8 is_dirt_needed;
+        u8 is_ptr_pos_needed;
+        u8 is_ptr_shape_needed;
+        u8 is_situ_needed;
+} __packed;
+
+struct rect {
+        s32 x1, y1; /* top left corner */
+        s32 x2, y2; /* bottom right corner, exclusive */
+} __packed;
+
+struct synthvid_dirt {
+        u8 video_output;
+        u8 dirt_count;
+        struct rect rect[1];
+} __packed;
+
+struct synthvid_msg {
+        struct pipe_msg_hdr pipe_hdr;
+        struct synthvid_msg_hdr vid_hdr;
+        union {
+                struct synthvid_version_req ver_req;
+                struct synthvid_version_resp ver_resp;
+                struct synthvid_vram_location vram;
+                struct synthvid_vram_location_ack vram_ack;
+                struct synthvid_situation_update situ;
+                struct synthvid_situation_update_ack situ_ack;
+                struct synthvid_pointer_position ptr_pos;
+                struct synthvid_pointer_shape ptr_shape;
+                struct synthvid_feature_change feature_chg;
+                struct synthvid_dirt dirt;
+        };
+} __packed;
+
+
+
+/* FB driver definitions and structures */
+#define HVFB_WIDTH 1152 /* default screen width */
+#define HVFB_HEIGHT 864 /* default screen height */
+#define HVFB_WIDTH_MIN 640
+#define HVFB_HEIGHT_MIN 480
+
+#define RING_BUFSIZE (256 * 1024)
+#define VSP_TIMEOUT (10 * HZ)
+#define HVFB_UPDATE_DELAY (HZ / 20)
+
+struct hvfb_par {
+        struct fb_info *info;
+        bool fb_ready; /* fb device is ready */
+        struct completion wait;
+        u32 synthvid_version;
+
+        struct delayed_work dwork;
+        bool update;
+
+        u32 pseudo_palette[16];
+        u8 init_buf[MAX_VMBUS_PKT_SIZE];
+        u8 recv_buf[MAX_VMBUS_PKT_SIZE];
+};
+
+static uint screen_width = HVFB_WIDTH;
+static uint screen_height = HVFB_HEIGHT;
+static uint screen_depth;
+static uint screen_fb_size;
+
+/* Send message to Hyper-V host */
+static inline int synthvid_send(struct hv_device *hdev,
+                                struct synthvid_msg *msg)
+{
+        static atomic64_t request_id = ATOMIC64_INIT(0);
+        int ret;
+
+        msg->pipe_hdr.type = PIPE_MSG_DATA;
+        msg->pipe_hdr.size = msg->vid_hdr.size;
+
+        ret = vmbus_sendpacket(hdev->channel, msg,
+                               msg->vid_hdr.size + sizeof(struct pipe_msg_hdr),
+                               atomic64_inc_return(&request_id),
+                               VM_PKT_DATA_INBAND, 0);
+
+        if (ret)
+                pr_err("Unable to send packet via vmbus\n");
+
+        return ret;
+}
+
+
+/* Send screen resolution info to host */
+static int synthvid_send_situ(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct synthvid_msg msg;
+
+        if (!info)
+                return -ENODEV;
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+
+        msg.vid_hdr.type = SYNTHVID_SITUATION_UPDATE;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_situation_update);
+        msg.situ.user_ctx = 0;
+        msg.situ.video_output_count = 1;
+        msg.situ.video_output[0].active = 1;
+        msg.situ.video_output[0].vram_offset = 0;
+        msg.situ.video_output[0].depth_bits = info->var.bits_per_pixel;
+        msg.situ.video_output[0].width_pixels = info->var.xres;
+        msg.situ.video_output[0].height_pixels = info->var.yres;
+        msg.situ.video_output[0].pitch_bytes = info->fix.line_length;
+
+        synthvid_send(hdev, &msg);
+
+        return 0;
+}
+
+/* Send mouse pointer info to host */
+static int synthvid_send_ptr(struct hv_device *hdev)
+{
+        struct synthvid_msg msg;
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+        msg.vid_hdr.type = SYNTHVID_POINTER_POSITION;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_pointer_position);
+        msg.ptr_pos.is_visible = 1;
+        msg.ptr_pos.video_output = 0;
+        msg.ptr_pos.image_x = 0;
+        msg.ptr_pos.image_y = 0;
+        synthvid_send(hdev, &msg);
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+        msg.vid_hdr.type = SYNTHVID_POINTER_SHAPE;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_pointer_shape);
+        msg.ptr_shape.part_idx = CURSOR_COMPLETE;
+        msg.ptr_shape.is_argb = 1;
+        msg.ptr_shape.width = 1;
+        msg.ptr_shape.height = 1;
+        msg.ptr_shape.hot_x = 0;
+        msg.ptr_shape.hot_y = 0;
+        msg.ptr_shape.data[0] = 0;
+        msg.ptr_shape.data[1] = 1;
+        msg.ptr_shape.data[2] = 1;
+        msg.ptr_shape.data[3] = 1;
+        synthvid_send(hdev, &msg);
+
+        return 0;
+}
+
+/* Send updated screen area (dirty rectangle) location to host */
+static int synthvid_update(struct fb_info *info)
+{
+        struct hv_device *hdev = device_to_hv_device(info->device);
+        struct synthvid_msg msg;
+
+        memset(&msg, 0, sizeof(struct synthvid_msg));
+
+        msg.vid_hdr.type = SYNTHVID_DIRT;
+        msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_dirt);
+        msg.dirt.video_output = 0;
+        msg.dirt.dirt_count = 1;
+        msg.dirt.rect[0].x1 = 0;
+        msg.dirt.rect[0].y1 = 0;
+        msg.dirt.rect[0].x2 = info->var.xres;
+        msg.dirt.rect[0].y2 = info->var.yres;
+
+        synthvid_send(hdev, &msg);
+
+        return 0;
+}
+
+
+/*
+ * Actions on received messages from host:
+ * Complete the wait event.
+ * Or, reply with screen and cursor info.
+ */
+static void synthvid_recv_sub(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par;
+        struct synthvid_msg *msg;
+
+        if (!info)
+                return;
+
+        par = info->par;
+        msg = (struct synthvid_msg *)par->recv_buf;
+
+        /* Complete the wait event */
+        if (msg->vid_hdr.type == SYNTHVID_VERSION_RESPONSE ||
+            msg->vid_hdr.type == SYNTHVID_VRAM_LOCATION_ACK) {
+                memcpy(par->init_buf, msg, MAX_VMBUS_PKT_SIZE);
+                complete(&par->wait);
+                return;
+        }
+
+        /* Reply with screen and cursor info */
+        if (msg->vid_hdr.type == SYNTHVID_FEATURE_CHANGE) {
+                if (par->fb_ready) {
+                        synthvid_send_ptr(hdev);
+                        synthvid_send_situ(hdev);
+                }
+
+                par->update = msg->feature_chg.is_dirt_needed;
+                if (par->update)
+                        schedule_delayed_work(&par->dwork, HVFB_UPDATE_DELAY);
+        }
+}
+
+/* Receive callback for messages from the host */
+static void synthvid_receive(void *ctx)
+{
+        struct hv_device *hdev = ctx;
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par;
+        struct synthvid_msg *recv_buf;
+        u32 bytes_recvd;
+        u64 req_id;
+        int ret;
+
+        if (!info)
+                return;
+
+        par = info->par;
+        recv_buf = (struct synthvid_msg *)par->recv_buf;
+
+        do {
+                ret = vmbus_recvpacket(hdev->channel, recv_buf,
+                                       MAX_VMBUS_PKT_SIZE,
+                                       &bytes_recvd, &req_id);
+                if (bytes_recvd > 0 &&
+                    recv_buf->pipe_hdr.type == PIPE_MSG_DATA)
+                        synthvid_recv_sub(hdev);
+        } while (bytes_recvd > 0 && ret == 0);
+}
+
+/* Check synthetic video protocol version with the host */
+static int synthvid_negotiate_ver(struct hv_device *hdev, u32 ver)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+        struct synthvid_msg *msg = (struct synthvid_msg *)par->init_buf;
+        int t, ret = 0;
+
+        memset(msg, 0, sizeof(struct synthvid_msg));
+        msg->vid_hdr.type = SYNTHVID_VERSION_REQUEST;
+        msg->vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_version_req);
+        msg->ver_req.version = ver;
+        synthvid_send(hdev, msg);
+
+        t = wait_for_completion_timeout(&par->wait, VSP_TIMEOUT);
+        if (!t) {
+                pr_err("Time out on waiting version response\n");
+                ret = -ETIMEDOUT;
+                goto out;
+        }
+        if (!msg->ver_resp.is_accepted) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        par->synthvid_version = ver;
+
+out:
+        return ret;
+}
+
+/* Connect to VSP (Virtual Service Provider) on host */
+static int synthvid_connect_vsp(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+        int ret;
+
+        ret = vmbus_open(hdev->channel, RING_BUFSIZE, RING_BUFSIZE,
+                         NULL, 0, synthvid_receive, hdev);
+        if (ret) {
+                pr_err("Unable to open vmbus channel\n");
+                return ret;
+        }
+
+        /* Negotiate the protocol version with host */
+        if (vmbus_proto_version == VERSION_WS2008 ||
+            vmbus_proto_version == VERSION_WIN7)
+                ret = synthvid_negotiate_ver(hdev, SYNTHVID_VERSION_WIN7);
+        else
+                ret = synthvid_negotiate_ver(hdev, SYNTHVID_VERSION_WIN8);
+
+        if (ret) {
+                pr_err("Synthetic video device version not accepted\n");
+                goto error;
+        }
+
+        if (par->synthvid_version == SYNTHVID_VERSION_WIN7) {
+                screen_depth = SYNTHVID_DEPTH_WIN7;
+                screen_fb_size = SYNTHVID_FB_SIZE_WIN7;
+        } else {
+                screen_depth = SYNTHVID_DEPTH_WIN8;
+                screen_fb_size = SYNTHVID_FB_SIZE_WIN8;
+        }
+
+        return 0;
+
+error:
+        vmbus_close(hdev->channel);
+        return ret;
+}
+
+/* Send VRAM and Situation messages to the host */
+static int synthvid_send_config(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+        struct synthvid_msg *msg = (struct synthvid_msg *)par->init_buf;
+        int t, ret = 0;
+
+        /* Send VRAM location */
+        memset(msg, 0, sizeof(struct synthvid_msg));
+        msg->vid_hdr.type = SYNTHVID_VRAM_LOCATION;
+        msg->vid_hdr.size = sizeof(struct synthvid_msg_hdr) +
+                sizeof(struct synthvid_vram_location);
+        msg->vram.user_ctx = msg->vram.vram_gpa = info->fix.smem_start;
+        msg->vram.is_vram_gpa_specified = 1;
+        synthvid_send(hdev, msg);
+
+        t = wait_for_completion_timeout(&par->wait, VSP_TIMEOUT);
+        if (!t) {
+                pr_err("Time out on waiting vram location ack\n");
+                ret = -ETIMEDOUT;
+                goto out;
+        }
+        if (msg->vram_ack.user_ctx != info->fix.smem_start) {
+                pr_err("Unable to set VRAM location\n");
+                ret = -ENODEV;
+                goto out;
+        }
+
+        /* Send pointer and situation update */
+        synthvid_send_ptr(hdev);
+        synthvid_send_situ(hdev);
+
+out:
+        return ret;
+}
+
+
+/*
+ * Delayed work callback:
+ * It is called at HVFB_UPDATE_DELAY or longer time interval to process
+ * screen updates. It is re-scheduled if further update is necessary.
+ */
+static void hvfb_update_work(struct work_struct *w)
+{
+        struct hvfb_par *par = container_of(w, struct hvfb_par, dwork.work);
+        struct fb_info *info = par->info;
+
+        if (par->fb_ready)
+                synthvid_update(info);
+
+        if (par->update)
+                schedule_delayed_work(&par->dwork, HVFB_UPDATE_DELAY);
+}
+
+
+/* Framebuffer operation handlers */
+
+static int hvfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        if (var->xres < HVFB_WIDTH_MIN || var->yres < HVFB_HEIGHT_MIN ||
+            var->xres > screen_width || var->yres >  screen_height ||
+            var->bits_per_pixel != screen_depth)
+                return -EINVAL;
+
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        return 0;
+}
+
+static int hvfb_set_par(struct fb_info *info)
+{
+        struct hv_device *hdev = device_to_hv_device(info->device);
+
+        return synthvid_send_situ(hdev);
+}
+
+
+static inline u32 chan_to_field(u32 chan, struct fb_bitfield *bf)
+{
+        return ((chan & 0xffff) >> (16 - bf->length)) << bf->offset;
+}
+
+static int hvfb_setcolreg(unsigned regno, unsigned red, unsigned green,
+                          unsigned blue, unsigned transp, struct fb_info *info)
+{
+        u32 *pal = info->pseudo_palette;
+
+        if (regno > 15)
+                return -EINVAL;
+
+        pal[regno] = chan_to_field(red, &info->var.red)
+                | chan_to_field(green, &info->var.green)
+                | chan_to_field(blue, &info->var.blue)
+                | chan_to_field(transp, &info->var.transp);
+
+        return 0;
+}
+
+
+static struct fb_ops hvfb_ops = {
+        .owner = THIS_MODULE,
+        .fb_check_var = hvfb_check_var,
+        .fb_set_par = hvfb_set_par,
+        .fb_setcolreg = hvfb_setcolreg,
+        .fb_fillrect = cfb_fillrect,
+        .fb_copyarea = cfb_copyarea,
+        .fb_imageblit = cfb_imageblit,
+};
+
+
+/* Get options from kernel paramenter "video=" */
+static void hvfb_get_option(struct fb_info *info)
+{
+        struct hvfb_par *par = info->par;
+        char *opt = NULL, *p;
+        uint x = 0, y = 0;
+
+        if (fb_get_options(KBUILD_MODNAME, &opt) || !opt || !*opt)
+                return;
+
+        p = strsep(&opt, "x");
+        if (!*p || kstrtouint(p, 0, &x) ||
+            !opt || !*opt || kstrtouint(opt, 0, &y)) {
+                pr_err("Screen option is invalid: skipped\n");
+                return;
+        }
+
+        if (x < HVFB_WIDTH_MIN || y < HVFB_HEIGHT_MIN ||
+            (par->synthvid_version == SYNTHVID_VERSION_WIN8 &&
+             x * y * screen_depth / 8 > SYNTHVID_FB_SIZE_WIN8) ||
+            (par->synthvid_version == SYNTHVID_VERSION_WIN7 &&
+             (x > SYNTHVID_WIDTH_MAX_WIN7 || y > SYNTHVID_HEIGHT_MAX_WIN7))) {
+                pr_err("Screen resolution option is out of range: skipped\n");
+                return;
+        }
+
+        screen_width = x;
+        screen_height = y;
+        return;
+}
+
+
+/* Get framebuffer memory from Hyper-V video pci space */
+static int hvfb_getmem(struct fb_info *info)
+{
+        struct pci_dev *pdev;
+        ulong fb_phys;
+        void __iomem *fb_virt;
+
+        pdev = pci_get_device(PCI_VENDOR_ID_MICROSOFT,
+                              PCI_DEVICE_ID_HYPERV_VIDEO, NULL);
+        if (!pdev) {
+                pr_err("Unable to find PCI Hyper-V video\n");
+                return -ENODEV;
+        }
+
+        if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM) ||
+            pci_resource_len(pdev, 0) < screen_fb_size)
+                goto err1;
+
+        fb_phys = pci_resource_end(pdev, 0) - screen_fb_size + 1;
+        if (!request_mem_region(fb_phys, screen_fb_size, KBUILD_MODNAME))
+                goto err1;
+
+        fb_virt = ioremap(fb_phys, screen_fb_size);
+        if (!fb_virt)
+                goto err2;
+
+        info->apertures = alloc_apertures(1);
+        if (!info->apertures)
+                goto err3;
+
+        info->apertures->ranges[0].base = pci_resource_start(pdev, 0);
+        info->apertures->ranges[0].size = pci_resource_len(pdev, 0);
+        info->fix.smem_start = fb_phys;
+        info->fix.smem_len = screen_fb_size;
+        info->screen_base = fb_virt;
+        info->screen_size = screen_fb_size;
+
+        pci_dev_put(pdev);
+        return 0;
+
+err3:
+        iounmap(fb_virt);
+err2:
+        release_mem_region(fb_phys, screen_fb_size);
+err1:
+        pci_dev_put(pdev);
+        return -ENOMEM;
+}
+
+/* Release the framebuffer */
+static void hvfb_putmem(struct fb_info *info)
+{
+        iounmap(info->screen_base);
+        release_mem_region(info->fix.smem_start, screen_fb_size);
+}
+
+
+static int hvfb_probe(struct hv_device *hdev,
+                      const struct hv_vmbus_device_id *dev_id)
+{
+        struct fb_info *info;
+        struct hvfb_par *par;
+        int ret;
+
+        info = framebuffer_alloc(sizeof(struct hvfb_par), &hdev->device);
+        if (!info) {
+                pr_err("No memory for framebuffer info\n");
+                return -ENOMEM;
+        }
+
+        par = info->par;
+        par->info = info;
+        par->fb_ready = false;
+        init_completion(&par->wait);
+        INIT_DELAYED_WORK(&par->dwork, hvfb_update_work);
+
+        /* Connect to VSP */
+        hv_set_drvdata(hdev, info);
+        ret = synthvid_connect_vsp(hdev);
+        if (ret) {
+                pr_err("Unable to connect to VSP\n");
+                goto error1;
+        }
+
+        ret = hvfb_getmem(info);
+        if (ret) {
+                pr_err("No memory for framebuffer\n");
+                goto error2;
+        }
+
+        hvfb_get_option(info);
+        pr_info("Screen resolution: %dx%d, Color depth: %d\n",
+                screen_width, screen_height, screen_depth);
+
+
+        /* Set up fb_info */
+        info->flags = FBINFO_DEFAULT;
+
+        info->var.xres_virtual = info->var.xres = screen_width;
+        info->var.yres_virtual = info->var.yres = screen_height;
+        info->var.bits_per_pixel = screen_depth;
+
+        if (info->var.bits_per_pixel == 16) {
+                info->var.red = (struct fb_bitfield){11, 5, 0};
+                info->var.green = (struct fb_bitfield){5, 6, 0};
+                info->var.blue = (struct fb_bitfield){0, 5, 0};
+                info->var.transp = (struct fb_bitfield){0, 0, 0};
+        } else {
+                info->var.red = (struct fb_bitfield){16, 8, 0};
+                info->var.green = (struct fb_bitfield){8, 8, 0};
+                info->var.blue = (struct fb_bitfield){0, 8, 0};
+                info->var.transp = (struct fb_bitfield){24, 8, 0};
+        }
+
+        info->var.activate = FB_ACTIVATE_NOW;
+        info->var.height = -1;
+        info->var.width = -1;
+        info->var.vmode = FB_VMODE_NONINTERLACED;
+
+        strcpy(info->fix.id, KBUILD_MODNAME);
+        info->fix.type = FB_TYPE_PACKED_PIXELS;
+        info->fix.visual = FB_VISUAL_TRUECOLOR;
+        info->fix.line_length = screen_width * screen_depth / 8;
+        info->fix.accel = FB_ACCEL_NONE;
+
+        info->fbops = &hvfb_ops;
+        info->pseudo_palette = par->pseudo_palette;
+
+        /* Send config to host */
+        ret = synthvid_send_config(hdev);
+        if (ret)
+                goto error;
+
+        ret = register_framebuffer(info);
+        if (ret) {
+                pr_err("Unable to register framebuffer\n");
+                goto error;
+        }
+
+        par->fb_ready = true;
+
+        return 0;
+
+error:
+        hvfb_putmem(info);
+error2:
+        vmbus_close(hdev->channel);
+error1:
+        cancel_delayed_work_sync(&par->dwork);
+        hv_set_drvdata(hdev, NULL);
+        framebuffer_release(info);
+        return ret;
+}
+
+
+static int hvfb_remove(struct hv_device *hdev)
+{
+        struct fb_info *info = hv_get_drvdata(hdev);
+        struct hvfb_par *par = info->par;
+
+        par->update = false;
+        par->fb_ready = false;
+
+        unregister_framebuffer(info);
+        cancel_delayed_work_sync(&par->dwork);
+
+        vmbus_close(hdev->channel);
+        hv_set_drvdata(hdev, NULL);
+
+        hvfb_putmem(info);
+        framebuffer_release(info);
+
+        return 0;
+}
+
+
+static const struct hv_vmbus_device_id id_table[] = {
+        /* Synthetic Video Device GUID */
+        {HV_SYNTHVID_GUID},
+        {}
+};
+
+MODULE_DEVICE_TABLE(vmbus, id_table);
+
+static struct hv_driver hvfb_drv = {
+        .name = KBUILD_MODNAME,
+        .id_table = id_table,
+        .probe = hvfb_probe,
+        .remove = hvfb_remove,
+};
+
+
+static int __init hvfb_drv_init(void)
+{
+        return vmbus_driver_register(&hvfb_drv);
+}
+
+static void __exit hvfb_drv_exit(void)
+{
+        vmbus_driver_unregister(&hvfb_drv);
+}
+
+module_init(hvfb_drv_init);
+module_exit(hvfb_drv_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_VERSION(HV_DRV_VERSION);
+MODULE_DESCRIPTION("Microsoft Hyper-V Synthetic Video Frame Buffer Driver");