hyperv_drm_drv.c

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