1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright 2021 Microsoft
  4 */
  5
  6#include <linux/efi.h>
  7#include <linux/hyperv.h>
  8#include <linux/module.h>
  9#include <linux/pci.h>
 10
 11#include <drm/drm_aperture.h>
 12#include <drm/drm_atomic_helper.h>
 13#include <drm/drm_drv.h>
 14#include <drm/drm_fb_helper.h>
 15#include <drm/drm_gem_shmem_helper.h>
 16#include <drm/drm_simple_kms_helper.h>
 17
 18#include "hyperv_drm.h"
 19
 20#define DRIVER_NAME "hyperv_drm"
 21#define DRIVER_DESC "DRM driver for Hyper-V synthetic video device"
 22#define DRIVER_DATE "2020"
 23#define DRIVER_MAJOR 1
 24#define DRIVER_MINOR 0
 25
 26#define PCI_VENDOR_ID_MICROSOFT 0x1414
 27#define PCI_DEVICE_ID_HYPERV_VIDEO 0x5353
 28
 29DEFINE_DRM_GEM_FOPS(hv_fops);
 30
 31static struct drm_driver hyperv_driver = {
 32	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
 33
 34	.name		 = DRIVER_NAME,
 35	.desc		 = DRIVER_DESC,
 36	.date		 = DRIVER_DATE,
 37	.major		 = DRIVER_MAJOR,
 38	.minor		 = DRIVER_MINOR,
 39
 40	.fops		 = &hv_fops,
 41	DRM_GEM_SHMEM_DRIVER_OPS,
 42};
 43
 44static int hyperv_pci_probe(struct pci_dev *pdev,
 45			    const struct pci_device_id *ent)
 46{
 47	return 0;
 48}
 49
 50static void hyperv_pci_remove(struct pci_dev *pdev)
 51{
 52}
 53
 54static const struct pci_device_id hyperv_pci_tbl[] = {
 55	{
 56		.vendor = PCI_VENDOR_ID_MICROSOFT,
 57		.device = PCI_DEVICE_ID_HYPERV_VIDEO,
 58	},
 59	{ /* end of list */ }
 60};
 61
 62/*
 63 * PCI stub to support gen1 VM.
 64 */
 65static struct pci_driver hyperv_pci_driver = {
 66	.name =		KBUILD_MODNAME,
 67	.id_table =	hyperv_pci_tbl,
 68	.probe =	hyperv_pci_probe,
 69	.remove =	hyperv_pci_remove,
 70};
 71
 72static int hyperv_setup_gen1(struct hyperv_drm_device *hv)
 73{
 74	struct drm_device *dev = &hv->dev;
 75	struct pci_dev *pdev;
 76	int ret;
 77
 78	pdev = pci_get_device(PCI_VENDOR_ID_MICROSOFT,
 79			      PCI_DEVICE_ID_HYPERV_VIDEO, NULL);
 80	if (!pdev) {
 81		drm_err(dev, "Unable to find PCI Hyper-V video\n");
 82		return -ENODEV;
 83	}
 84
 85	ret = drm_aperture_remove_conflicting_pci_framebuffers(pdev, "hypervdrmfb");
 86	if (ret) {
 87		drm_err(dev, "Not able to remove boot fb\n");
 88		return ret;
 89	}
 90
 91	if (pci_request_region(pdev, 0, DRIVER_NAME) != 0)
 92		drm_warn(dev, "Cannot request framebuffer, boot fb still active?\n");
 93
 94	if ((pdev->resource[0].flags & IORESOURCE_MEM) == 0) {
 95		drm_err(dev, "Resource at bar 0 is not IORESOURCE_MEM\n");
 96		ret = -ENODEV;
 97		goto error;
 98	}
 99
100	hv->fb_base = pci_resource_start(pdev, 0);
101	hv->fb_size = pci_resource_len(pdev, 0);
102	if (!hv->fb_base) {
103		drm_err(dev, "Resource not available\n");
104		ret = -ENODEV;
105		goto error;
106	}
107
108	hv->fb_size = min(hv->fb_size,
109			  (unsigned long)(hv->mmio_megabytes * 1024 * 1024));
110	hv->vram = devm_ioremap(&pdev->dev, hv->fb_base, hv->fb_size);
111	if (!hv->vram) {
112		drm_err(dev, "Failed to map vram\n");
113		ret = -ENOMEM;
114	}
115
116error:
117	pci_dev_put(pdev);
118	return ret;
119}
120
121static int hyperv_setup_gen2(struct hyperv_drm_device *hv,
122			     struct hv_device *hdev)
123{
124	struct drm_device *dev = &hv->dev;
125	int ret;
126
127	drm_aperture_remove_conflicting_framebuffers(screen_info.lfb_base,
128						     screen_info.lfb_size,
129						     false,
130						     "hypervdrmfb");
131
132	hv->fb_size = (unsigned long)hv->mmio_megabytes * 1024 * 1024;
133
134	ret = vmbus_allocate_mmio(&hv->mem, hdev, 0, -1, hv->fb_size, 0x100000,
135				  true);
136	if (ret) {
137		drm_err(dev, "Failed to allocate mmio\n");
138		return -ENOMEM;
139	}
140
141	/*
142	 * Map the VRAM cacheable for performance. This is also required for VM
143	 * connect to display properly for ARM64 Linux VM, as the host also maps
144	 * the VRAM cacheable.
145	 */
146	hv->vram = ioremap_cache(hv->mem->start, hv->fb_size);
147	if (!hv->vram) {
148		drm_err(dev, "Failed to map vram\n");
149		ret = -ENOMEM;
150		goto error;
151	}
152
153	hv->fb_base = hv->mem->start;
154	return 0;
155
156error:
157	vmbus_free_mmio(hv->mem->start, hv->fb_size);
158	return ret;
159}
160
161static int hyperv_vmbus_probe(struct hv_device *hdev,
162			      const struct hv_vmbus_device_id *dev_id)
163{
164	struct hyperv_drm_device *hv;
165	struct drm_device *dev;
166	int ret;
167
168	hv = devm_drm_dev_alloc(&hdev->device, &hyperv_driver,
169				struct hyperv_drm_device, dev);
170	if (IS_ERR(hv))
171		return PTR_ERR(hv);
172
173	dev = &hv->dev;
174	init_completion(&hv->wait);
175	hv_set_drvdata(hdev, hv);
176	hv->hdev = hdev;
177
178	ret = hyperv_connect_vsp(hdev);
179	if (ret) {
180		drm_err(dev, "Failed to connect to vmbus.\n");
181		goto err_hv_set_drv_data;
182	}
183
184	if (efi_enabled(EFI_BOOT))
185		ret = hyperv_setup_gen2(hv, hdev);
186	else
187		ret = hyperv_setup_gen1(hv);
188
 
189	if (ret)
190		goto err_vmbus_close;
191
192	/*
193	 * Should be done only once during init and resume. Failing to update
194	 * vram location is not fatal. Device will update dirty area till
195	 * preferred resolution only.
196	 */
197	ret = hyperv_update_vram_location(hdev, hv->fb_base);
198	if (ret)
199		drm_warn(dev, "Failed to update vram location.\n");
200
201	hv->dirt_needed = true;
202
203	ret = hyperv_mode_config_init(hv);
204	if (ret)
205		goto err_vmbus_close;
206
207	ret = drm_dev_register(dev, 0);
208	if (ret) {
209		drm_err(dev, "Failed to register drm driver.\n");
210		goto err_vmbus_close;
211	}
212
213	drm_fbdev_generic_setup(dev, 0);
214
215	return 0;
216
 
 
217err_vmbus_close:
218	vmbus_close(hdev->channel);
219err_hv_set_drv_data:
220	hv_set_drvdata(hdev, NULL);
221	return ret;
222}
223
224static int hyperv_vmbus_remove(struct hv_device *hdev)
225{
226	struct drm_device *dev = hv_get_drvdata(hdev);
227	struct hyperv_drm_device *hv = to_hv(dev);
228
229	drm_dev_unplug(dev);
230	drm_atomic_helper_shutdown(dev);
231	vmbus_close(hdev->channel);
232	hv_set_drvdata(hdev, NULL);
 
233	vmbus_free_mmio(hv->mem->start, hv->fb_size);
 
234
235	return 0;
 
 
236}
237
238static int hyperv_vmbus_suspend(struct hv_device *hdev)
239{
240	struct drm_device *dev = hv_get_drvdata(hdev);
241	int ret;
242
243	ret = drm_mode_config_helper_suspend(dev);
244	if (ret)
245		return ret;
246
247	vmbus_close(hdev->channel);
248
249	return 0;
250}
251
252static int hyperv_vmbus_resume(struct hv_device *hdev)
253{
254	struct drm_device *dev = hv_get_drvdata(hdev);
255	struct hyperv_drm_device *hv = to_hv(dev);
256	int ret;
257
258	ret = hyperv_connect_vsp(hdev);
259	if (ret)
260		return ret;
261
262	ret = hyperv_update_vram_location(hdev, hv->fb_base);
263	if (ret)
264		return ret;
265
266	return drm_mode_config_helper_resume(dev);
267}
268
269static const struct hv_vmbus_device_id hyperv_vmbus_tbl[] = {
270	/* Synthetic Video Device GUID */
271	{HV_SYNTHVID_GUID},
272	{}
273};
274
275static struct hv_driver hyperv_hv_driver = {
276	.name = KBUILD_MODNAME,
277	.id_table = hyperv_vmbus_tbl,
278	.probe = hyperv_vmbus_probe,
279	.remove = hyperv_vmbus_remove,
 
280	.suspend = hyperv_vmbus_suspend,
281	.resume = hyperv_vmbus_resume,
282	.driver = {
283		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
284	},
285};
286
287static int __init hyperv_init(void)
288{
289	int ret;
 
 
 
290
291	ret = pci_register_driver(&hyperv_pci_driver);
292	if (ret != 0)
293		return ret;
294
295	return vmbus_driver_register(&hyperv_hv_driver);
296}
297
298static void __exit hyperv_exit(void)
299{
300	vmbus_driver_unregister(&hyperv_hv_driver);
301	pci_unregister_driver(&hyperv_pci_driver);
302}
303
304module_init(hyperv_init);
305module_exit(hyperv_exit);
306
307MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl);
308MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl);
309MODULE_LICENSE("GPL");
310MODULE_AUTHOR("Deepak Rawat <drawat.floss@gmail.com>");
311MODULE_DESCRIPTION("DRM driver for Hyper-V synthetic video device");

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright 2021 Microsoft
  4 */
  5
  6#include <linux/efi.h>
  7#include <linux/hyperv.h>
  8#include <linux/module.h>
  9#include <linux/pci.h>
 10
 11#include <drm/drm_aperture.h>
 12#include <drm/drm_atomic_helper.h>
 13#include <drm/drm_drv.h>
 14#include <drm/drm_fbdev_generic.h>
 15#include <drm/drm_gem_shmem_helper.h>
 16#include <drm/drm_simple_kms_helper.h>
 17
 18#include "hyperv_drm.h"
 19
 20#define DRIVER_NAME "hyperv_drm"
 21#define DRIVER_DESC "DRM driver for Hyper-V synthetic video device"
 22#define DRIVER_DATE "2020"
 23#define DRIVER_MAJOR 1
 24#define DRIVER_MINOR 0
 25
 
 
 
 26DEFINE_DRM_GEM_FOPS(hv_fops);
 27
 28static struct drm_driver hyperv_driver = {
 29	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
 30
 31	.name		 = DRIVER_NAME,
 32	.desc		 = DRIVER_DESC,
 33	.date		 = DRIVER_DATE,
 34	.major		 = DRIVER_MAJOR,
 35	.minor		 = DRIVER_MINOR,
 36
 37	.fops		 = &hv_fops,
 38	DRM_GEM_SHMEM_DRIVER_OPS,
 39};
 40
 41static int hyperv_pci_probe(struct pci_dev *pdev,
 42			    const struct pci_device_id *ent)
 43{
 44	return 0;
 45}
 46
 47static void hyperv_pci_remove(struct pci_dev *pdev)
 48{
 49}
 50
 51static const struct pci_device_id hyperv_pci_tbl[] = {
 52	{
 53		.vendor = PCI_VENDOR_ID_MICROSOFT,
 54		.device = PCI_DEVICE_ID_HYPERV_VIDEO,
 55	},
 56	{ /* end of list */ }
 57};
 58
 59/*
 60 * PCI stub to support gen1 VM.
 61 */
 62static struct pci_driver hyperv_pci_driver = {
 63	.name =		KBUILD_MODNAME,
 64	.id_table =	hyperv_pci_tbl,
 65	.probe =	hyperv_pci_probe,
 66	.remove =	hyperv_pci_remove,
 67};
 68
 69static int hyperv_setup_vram(struct hyperv_drm_device *hv,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 70			     struct hv_device *hdev)
 71{
 72	struct drm_device *dev = &hv->dev;
 73	int ret;
 74
 
 
 
 
 
 75	hv->fb_size = (unsigned long)hv->mmio_megabytes * 1024 * 1024;
 76
 77	ret = vmbus_allocate_mmio(&hv->mem, hdev, 0, -1, hv->fb_size, 0x100000,
 78				  true);
 79	if (ret) {
 80		drm_err(dev, "Failed to allocate mmio\n");
 81		return -ENOMEM;
 82	}
 83
 84	/*
 85	 * Map the VRAM cacheable for performance. This is also required for VM
 86	 * connect to display properly for ARM64 Linux VM, as the host also maps
 87	 * the VRAM cacheable.
 88	 */
 89	hv->vram = ioremap_cache(hv->mem->start, hv->fb_size);
 90	if (!hv->vram) {
 91		drm_err(dev, "Failed to map vram\n");
 92		ret = -ENOMEM;
 93		goto error;
 94	}
 95
 96	hv->fb_base = hv->mem->start;
 97	return 0;
 98
 99error:
100	vmbus_free_mmio(hv->mem->start, hv->fb_size);
101	return ret;
102}
103
104static int hyperv_vmbus_probe(struct hv_device *hdev,
105			      const struct hv_vmbus_device_id *dev_id)
106{
107	struct hyperv_drm_device *hv;
108	struct drm_device *dev;
109	int ret;
110
111	hv = devm_drm_dev_alloc(&hdev->device, &hyperv_driver,
112				struct hyperv_drm_device, dev);
113	if (IS_ERR(hv))
114		return PTR_ERR(hv);
115
116	dev = &hv->dev;
117	init_completion(&hv->wait);
118	hv_set_drvdata(hdev, hv);
119	hv->hdev = hdev;
120
121	ret = hyperv_connect_vsp(hdev);
122	if (ret) {
123		drm_err(dev, "Failed to connect to vmbus.\n");
124		goto err_hv_set_drv_data;
125	}
126
127	drm_aperture_remove_framebuffers(&hyperv_driver);
 
 
 
128
129	ret = hyperv_setup_vram(hv, hdev);
130	if (ret)
131		goto err_vmbus_close;
132
133	/*
134	 * Should be done only once during init and resume. Failing to update
135	 * vram location is not fatal. Device will update dirty area till
136	 * preferred resolution only.
137	 */
138	ret = hyperv_update_vram_location(hdev, hv->fb_base);
139	if (ret)
140		drm_warn(dev, "Failed to update vram location.\n");
141
 
 
142	ret = hyperv_mode_config_init(hv);
143	if (ret)
144		goto err_free_mmio;
145
146	ret = drm_dev_register(dev, 0);
147	if (ret) {
148		drm_err(dev, "Failed to register drm driver.\n");
149		goto err_free_mmio;
150	}
151
152	drm_fbdev_generic_setup(dev, 0);
153
154	return 0;
155
156err_free_mmio:
157	vmbus_free_mmio(hv->mem->start, hv->fb_size);
158err_vmbus_close:
159	vmbus_close(hdev->channel);
160err_hv_set_drv_data:
161	hv_set_drvdata(hdev, NULL);
162	return ret;
163}
164
165static void hyperv_vmbus_remove(struct hv_device *hdev)
166{
167	struct drm_device *dev = hv_get_drvdata(hdev);
168	struct hyperv_drm_device *hv = to_hv(dev);
169
170	drm_dev_unplug(dev);
171	drm_atomic_helper_shutdown(dev);
172	vmbus_close(hdev->channel);
173	hv_set_drvdata(hdev, NULL);
174
175	vmbus_free_mmio(hv->mem->start, hv->fb_size);
176}
177
178static void hyperv_vmbus_shutdown(struct hv_device *hdev)
179{
180	drm_atomic_helper_shutdown(hv_get_drvdata(hdev));
181}
182
183static int hyperv_vmbus_suspend(struct hv_device *hdev)
184{
185	struct drm_device *dev = hv_get_drvdata(hdev);
186	int ret;
187
188	ret = drm_mode_config_helper_suspend(dev);
189	if (ret)
190		return ret;
191
192	vmbus_close(hdev->channel);
193
194	return 0;
195}
196
197static int hyperv_vmbus_resume(struct hv_device *hdev)
198{
199	struct drm_device *dev = hv_get_drvdata(hdev);
200	struct hyperv_drm_device *hv = to_hv(dev);
201	int ret;
202
203	ret = hyperv_connect_vsp(hdev);
204	if (ret)
205		return ret;
206
207	ret = hyperv_update_vram_location(hdev, hv->fb_base);
208	if (ret)
209		return ret;
210
211	return drm_mode_config_helper_resume(dev);
212}
213
214static const struct hv_vmbus_device_id hyperv_vmbus_tbl[] = {
215	/* Synthetic Video Device GUID */
216	{HV_SYNTHVID_GUID},
217	{}
218};
219
220static struct hv_driver hyperv_hv_driver = {
221	.name = KBUILD_MODNAME,
222	.id_table = hyperv_vmbus_tbl,
223	.probe = hyperv_vmbus_probe,
224	.remove = hyperv_vmbus_remove,
225	.shutdown = hyperv_vmbus_shutdown,
226	.suspend = hyperv_vmbus_suspend,
227	.resume = hyperv_vmbus_resume,
228	.driver = {
229		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
230	},
231};
232
233static int __init hyperv_init(void)
234{
235	int ret;
236
237	if (drm_firmware_drivers_only())
238		return -ENODEV;
239
240	ret = pci_register_driver(&hyperv_pci_driver);
241	if (ret != 0)
242		return ret;
243
244	return vmbus_driver_register(&hyperv_hv_driver);
245}
246
247static void __exit hyperv_exit(void)
248{
249	vmbus_driver_unregister(&hyperv_hv_driver);
250	pci_unregister_driver(&hyperv_pci_driver);
251}
252
253module_init(hyperv_init);
254module_exit(hyperv_exit);
255
256MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl);
257MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl);
258MODULE_LICENSE("GPL");
259MODULE_AUTHOR("Deepak Rawat <drawat.floss@gmail.com>");
260MODULE_DESCRIPTION("DRM driver for Hyper-V synthetic video device");