Commit 76c56a5a authored by Deepak Rawat's avatar Deepak Rawat
Browse files

drm/hyperv: Add DRM driver for hyperv synthetic video device 



DRM driver for hyperv synthetic video device, based on hyperv_fb
framebuffer driver. Also added config option "DRM_HYPERV" to enabled
this driver.

v2:
- Add support for gen2 VM
- Fixed review comments

v3:
- Split into multiple files as suggested by Thomas Zimmermann
- Fixed hibernation issue as suggested by Dexuan Cui
- Use ioremap_cache as suggested by Dexuan Cui
- Incorporated other review comments

v4:
- Fix bitrotted code
- Review comments
- Updated the copyright and license to match hyperv_fb

v5:
- Address review comments and rebased with drm-misc-next

v6:
- Minor code/comment improvement as suggested by Dexuan Cui

Signed-off-by: default avatarDeepak Rawat <drawat.floss@gmail.com>
Acked-by: default avatarThomas Zimmermann <tzimmermann@suse.de>
Link: https://patchwork.freedesktop.org/patch/msgid/20210527112230.1274-1-drawat.floss@gmail.com
parent abb50d67

drivers/gpu/drm/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -379,6 +379,19 @@ source "drivers/gpu/drm/xlnx/Kconfig" 


source "drivers/gpu/drm/gud/Kconfig"



config DRM_HYPERV

	tristate "DRM Support for Hyper-V synthetic video device"

	depends on DRM && PCI && MMU && HYPERV

	select DRM_KMS_HELPER

	select DRM_GEM_SHMEM_HELPER

	help

	 This is a KMS driver for Hyper-V synthetic video device. Choose this

	 option if you would like to enable drm driver for Hyper-V virtual

	 machine. Unselect Hyper-V framebuffer driver (CONFIG_FB_HYPERV) so

	 that DRM driver is used by default.



	 If M is selected the module will be called hyperv_drm.



# Keep legacy drivers last



menuconfig DRM_LEGACY

drivers/gpu/drm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -126,3 +126,4 @@ obj-$(CONFIG_DRM_MCDE) += mcde/ 
obj-$(CONFIG_DRM_TIDSS) += tidss/

obj-y			+= xlnx/

obj-y			+= gud/

obj-$(CONFIG_DRM_HYPERV) += hyperv/

drivers/gpu/drm/hyperv/Makefile

0 → 100644
+8 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only



hyperv_drm-y := \

	hyperv_drm_drv.o \

	hyperv_drm_modeset.o \

	hyperv_drm_proto.o



obj-$(CONFIG_DRM_HYPERV) += hyperv_drm.o

drivers/gpu/drm/hyperv/hyperv_drm.h

0 → 100644
+51 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright 2021 Microsoft

 */



#ifndef _HYPERV_DRM_H_

#define _HYPERV_DRM_H_



#define VMBUS_MAX_PACKET_SIZE 0x4000



struct hyperv_drm_device {

	/* drm */

	struct drm_device dev;

	struct drm_simple_display_pipe pipe;

	struct drm_connector connector;



	/* mode */

	u32 screen_width_max;

	u32 screen_height_max;

	u32 preferred_width;

	u32 preferred_height;

	u32 screen_depth;



	/* hw */

	struct resource *mem;

	void __iomem *vram;

	unsigned long fb_base;

	unsigned long fb_size;

	struct completion wait;

	u32 synthvid_version;

	u32 mmio_megabytes;



	u8 init_buf[VMBUS_MAX_PACKET_SIZE];

	u8 recv_buf[VMBUS_MAX_PACKET_SIZE];



	struct hv_device *hdev;

};



#define to_hv(_dev) container_of(_dev, struct hyperv_drm_device, dev)



/* hyperv_drm_modeset */

int hyperv_mode_config_init(struct hyperv_drm_device *hv);



/* hyperv_drm_proto */

int hyperv_update_vram_location(struct hv_device *hdev, phys_addr_t vram_pp);

int hyperv_update_situation(struct hv_device *hdev, u8 active, u32 bpp,

			    u32 w, u32 h, u32 pitch);

int hyperv_update_dirt(struct hv_device *hdev, struct drm_rect *rect);

int hyperv_connect_vsp(struct hv_device *hdev);



#endif

drivers/gpu/drm/hyperv/hyperv_drm_drv.c

0 → 100644
+309 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright 2021 Microsoft

 */



#include <linux/efi.h>

#include <linux/hyperv.h>

#include <linux/module.h>

#include <linux/pci.h>



#include <drm/drm_aperture.h>

#include <drm/drm_atomic_helper.h>

#include <drm/drm_drv.h>

#include <drm/drm_fb_helper.h>

#include <drm/drm_gem_shmem_helper.h>

#include <drm/drm_simple_kms_helper.h>



#include "hyperv_drm.h"



#define DRIVER_NAME "hyperv_drm"

#define DRIVER_DESC "DRM driver for Hyper-V synthetic video device"

#define DRIVER_DATE "2020"

#define DRIVER_MAJOR 1

#define DRIVER_MINOR 0



#define PCI_VENDOR_ID_MICROSOFT 0x1414

#define PCI_DEVICE_ID_HYPERV_VIDEO 0x5353



DEFINE_DRM_GEM_FOPS(hv_fops);



static struct drm_driver hyperv_driver = {

	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,



	.name		 = DRIVER_NAME,

	.desc		 = DRIVER_DESC,

	.date		 = DRIVER_DATE,

	.major		 = DRIVER_MAJOR,

	.minor		 = DRIVER_MINOR,



	.fops		 = &hv_fops,

	DRM_GEM_SHMEM_DRIVER_OPS,

};



static int hyperv_pci_probe(struct pci_dev *pdev,

			    const struct pci_device_id *ent)

{

	return 0;

}



static void hyperv_pci_remove(struct pci_dev *pdev)

{

}



static const struct pci_device_id hyperv_pci_tbl[] = {

	{

		.vendor = PCI_VENDOR_ID_MICROSOFT,

		.device = PCI_DEVICE_ID_HYPERV_VIDEO,

	},

	{ /* end of list */ }

};



/*

 * PCI stub to support gen1 VM.

 */

static struct pci_driver hyperv_pci_driver = {

	.name =		KBUILD_MODNAME,

	.id_table =	hyperv_pci_tbl,

	.probe =	hyperv_pci_probe,

	.remove =	hyperv_pci_remove,

};



static int hyperv_setup_gen1(struct hyperv_drm_device *hv)

{

	struct drm_device *dev = &hv->dev;

	struct pci_dev *pdev;

	int ret;



	pdev = pci_get_device(PCI_VENDOR_ID_MICROSOFT,

			      PCI_DEVICE_ID_HYPERV_VIDEO, NULL);

	if (!pdev) {

		drm_err(dev, "Unable to find PCI Hyper-V video\n");

		return -ENODEV;

	}



	ret = drm_aperture_remove_conflicting_pci_framebuffers(pdev, "hypervdrmfb");

	if (ret) {

		drm_err(dev, "Not able to remove boot fb\n");

		return ret;

	}



	if (pci_request_region(pdev, 0, DRIVER_NAME) != 0)

		drm_warn(dev, "Cannot request framebuffer, boot fb still active?\n");



	if ((pdev->resource[0].flags & IORESOURCE_MEM) == 0) {

		drm_err(dev, "Resource at bar 0 is not IORESOURCE_MEM\n");

		ret = -ENODEV;

		goto error;

	}



	hv->fb_base = pci_resource_start(pdev, 0);

	hv->fb_size = pci_resource_len(pdev, 0);

	if (!hv->fb_base) {

		drm_err(dev, "Resource not available\n");

		ret = -ENODEV;

		goto error;

	}



	hv->fb_size = min(hv->fb_size,

			  (unsigned long)(hv->mmio_megabytes * 1024 * 1024));

	hv->vram = devm_ioremap(&pdev->dev, hv->fb_base, hv->fb_size);

	if (!hv->vram) {

		drm_err(dev, "Failed to map vram\n");

		ret = -ENOMEM;

	}



error:

	pci_dev_put(pdev);

	return ret;

}



static int hyperv_setup_gen2(struct hyperv_drm_device *hv,

			     struct hv_device *hdev)

{

	struct drm_device *dev = &hv->dev;

	int ret;



	drm_aperture_remove_conflicting_framebuffers(screen_info.lfb_base,

						     screen_info.lfb_size,

						     false,

						     "hypervdrmfb");



	hv->fb_size = (unsigned long)hv->mmio_megabytes * 1024 * 1024;



	ret = vmbus_allocate_mmio(&hv->mem, hdev, 0, -1, hv->fb_size, 0x100000,

				  true);

	if (ret) {

		drm_err(dev, "Failed to allocate mmio\n");

		return -ENOMEM;

	}



	/*

	 * Map the VRAM cacheable for performance. This is also required for VM

	 * connect to display properly for ARM64 Linux VM, as the host also maps

	 * the VRAM cacheable.

	 */

	hv->vram = ioremap_cache(hv->mem->start, hv->fb_size);

	if (!hv->vram) {

		drm_err(dev, "Failed to map vram\n");

		ret = -ENOMEM;

		goto error;

	}



	hv->fb_base = hv->mem->start;

	return 0;



error:

	vmbus_free_mmio(hv->mem->start, hv->fb_size);

	return ret;

}



static int hyperv_vmbus_probe(struct hv_device *hdev,

			      const struct hv_vmbus_device_id *dev_id)

{

	struct hyperv_drm_device *hv;

	struct drm_device *dev;

	int ret;



	hv = devm_drm_dev_alloc(&hdev->device, &hyperv_driver,

				struct hyperv_drm_device, dev);

	if (IS_ERR(hv))

		return PTR_ERR(hv);



	dev = &hv->dev;

	init_completion(&hv->wait);

	hv_set_drvdata(hdev, hv);

	hv->hdev = hdev;



	ret = hyperv_connect_vsp(hdev);

	if (ret) {

		drm_err(dev, "Failed to connect to vmbus.\n");

		goto err_hv_set_drv_data;

	}



	if (efi_enabled(EFI_BOOT))

		ret = hyperv_setup_gen2(hv, hdev);

	else

		ret = hyperv_setup_gen1(hv);



	if (ret)

		goto err_vmbus_close;



	/*

	 * Should be done only once during init and resume. Failing to update

	 * vram location is not fatal. Device will update dirty area till

	 * preferred resolution only.

	 */

	ret = hyperv_update_vram_location(hdev, hv->fb_base);

	if (ret)

		drm_warn(dev, "Failed to update vram location.\n");



	ret = hyperv_mode_config_init(hv);

	if (ret)

		goto err_vmbus_close;



	ret = drm_dev_register(dev, 0);

	if (ret) {

		drm_err(dev, "Failed to register drm driver.\n");

		goto err_vmbus_close;

	}



	drm_fbdev_generic_setup(dev, 0);



	return 0;



err_vmbus_close:

	vmbus_close(hdev->channel);

err_hv_set_drv_data:

	hv_set_drvdata(hdev, NULL);

	return ret;

}



static int hyperv_vmbus_remove(struct hv_device *hdev)

{

	struct drm_device *dev = hv_get_drvdata(hdev);

	struct hyperv_drm_device *hv = to_hv(dev);



	drm_dev_unplug(dev);

	drm_atomic_helper_shutdown(dev);

	vmbus_close(hdev->channel);

	hv_set_drvdata(hdev, NULL);

	vmbus_free_mmio(hv->mem->start, hv->fb_size);



	return 0;

}



static int hyperv_vmbus_suspend(struct hv_device *hdev)

{

	struct drm_device *dev = hv_get_drvdata(hdev);

	int ret;



	ret = drm_mode_config_helper_suspend(dev);

	if (ret)

		return ret;



	vmbus_close(hdev->channel);



	return 0;

}



static int hyperv_vmbus_resume(struct hv_device *hdev)

{

	struct drm_device *dev = hv_get_drvdata(hdev);

	struct hyperv_drm_device *hv = to_hv(dev);

	int ret;



	ret = hyperv_connect_vsp(hdev);

	if (ret)

		return ret;



	ret = hyperv_update_vram_location(hdev, hv->fb_base);

	if (ret)

		return ret;



	return drm_mode_config_helper_resume(dev);

}



static const struct hv_vmbus_device_id hyperv_vmbus_tbl[] = {

	/* Synthetic Video Device GUID */

	{HV_SYNTHVID_GUID},

	{}

};



static struct hv_driver hyperv_hv_driver = {

	.name = KBUILD_MODNAME,

	.id_table = hyperv_vmbus_tbl,

	.probe = hyperv_vmbus_probe,

	.remove = hyperv_vmbus_remove,

	.suspend = hyperv_vmbus_suspend,

	.resume = hyperv_vmbus_resume,

	.driver = {

		.probe_type = PROBE_PREFER_ASYNCHRONOUS,

	},

};



static int __init hyperv_init(void)

{

	int ret;



	ret = pci_register_driver(&hyperv_pci_driver);

	if (ret != 0)

		return ret;



	return vmbus_driver_register(&hyperv_hv_driver);

}



static void __exit hyperv_exit(void)

{

	vmbus_driver_unregister(&hyperv_hv_driver);

	pci_unregister_driver(&hyperv_pci_driver);

}



module_init(hyperv_init);

module_exit(hyperv_exit);



MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl);

MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl);

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Deepak Rawat <drawat.floss@gmail.com>");

MODULE_DESCRIPTION("DRM driver for Hyper-V synthetic video device");