xref: /linux/drivers/gpu/drm/hyperv/hyperv_drm_drv.c (revision 0fed89a961ea851945d23cc35beb59d6e56c0964)
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_simple_kms_helper.h>
18 
19 #include "hyperv_drm.h"
20 
21 #define DRIVER_NAME "hyperv_drm"
22 #define DRIVER_DESC "DRM driver for Hyper-V synthetic video device"
23 #define DRIVER_MAJOR 1
24 #define DRIVER_MINOR 0
25 
26 DEFINE_DRM_GEM_FOPS(hv_fops);
27 
28 static struct drm_driver hyperv_driver = {
29 	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
30 
31 	.name		 = DRIVER_NAME,
32 	.desc		 = DRIVER_DESC,
33 	.major		 = DRIVER_MAJOR,
34 	.minor		 = DRIVER_MINOR,
35 
36 	.fops		 = &hv_fops,
37 	DRM_GEM_SHMEM_DRIVER_OPS,
38 	DRM_FBDEV_SHMEM_DRIVER_OPS,
39 };
40 
hyperv_pci_probe(struct pci_dev * pdev,const struct pci_device_id * ent)41 static int hyperv_pci_probe(struct pci_dev *pdev,
42 			    const struct pci_device_id *ent)
43 {
44 	return 0;
45 }
46 
hyperv_pci_remove(struct pci_dev * pdev)47 static void hyperv_pci_remove(struct pci_dev *pdev)
48 {
49 }
50 
51 static 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  */
62 static 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 
hyperv_setup_vram(struct hyperv_drm_device * hv,struct hv_device * hdev)69 static 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 
99 error:
100 	vmbus_free_mmio(hv->mem->start, hv->fb_size);
101 	return ret;
102 }
103 
hyperv_vmbus_probe(struct hv_device * hdev,const struct hv_vmbus_device_id * dev_id)104 static 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 	aperture_remove_all_conflicting_devices(hyperv_driver.name);
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_client_setup(dev, NULL);
153 
154 	return 0;
155 
156 err_free_mmio:
157 	iounmap(hv->vram);
158 	vmbus_free_mmio(hv->mem->start, hv->fb_size);
159 err_vmbus_close:
160 	vmbus_close(hdev->channel);
161 err_hv_set_drv_data:
162 	hv_set_drvdata(hdev, NULL);
163 	return ret;
164 }
165 
hyperv_vmbus_remove(struct hv_device * hdev)166 static void hyperv_vmbus_remove(struct hv_device *hdev)
167 {
168 	struct drm_device *dev = hv_get_drvdata(hdev);
169 	struct hyperv_drm_device *hv = to_hv(dev);
170 
171 	drm_dev_unplug(dev);
172 	drm_atomic_helper_shutdown(dev);
173 	vmbus_close(hdev->channel);
174 	hv_set_drvdata(hdev, NULL);
175 
176 	iounmap(hv->vram);
177 	vmbus_free_mmio(hv->mem->start, hv->fb_size);
178 }
179 
hyperv_vmbus_shutdown(struct hv_device * hdev)180 static void hyperv_vmbus_shutdown(struct hv_device *hdev)
181 {
182 	drm_atomic_helper_shutdown(hv_get_drvdata(hdev));
183 }
184 
hyperv_vmbus_suspend(struct hv_device * hdev)185 static int hyperv_vmbus_suspend(struct hv_device *hdev)
186 {
187 	struct drm_device *dev = hv_get_drvdata(hdev);
188 	int ret;
189 
190 	ret = drm_mode_config_helper_suspend(dev);
191 	if (ret)
192 		return ret;
193 
194 	vmbus_close(hdev->channel);
195 
196 	return 0;
197 }
198 
hyperv_vmbus_resume(struct hv_device * hdev)199 static int hyperv_vmbus_resume(struct hv_device *hdev)
200 {
201 	struct drm_device *dev = hv_get_drvdata(hdev);
202 	struct hyperv_drm_device *hv = to_hv(dev);
203 	int ret;
204 
205 	ret = hyperv_connect_vsp(hdev);
206 	if (ret)
207 		return ret;
208 
209 	ret = hyperv_update_vram_location(hdev, hv->fb_base);
210 	if (ret)
211 		return ret;
212 
213 	return drm_mode_config_helper_resume(dev);
214 }
215 
216 static const struct hv_vmbus_device_id hyperv_vmbus_tbl[] = {
217 	/* Synthetic Video Device GUID */
218 	{HV_SYNTHVID_GUID},
219 	{}
220 };
221 
222 static struct hv_driver hyperv_hv_driver = {
223 	.name = KBUILD_MODNAME,
224 	.id_table = hyperv_vmbus_tbl,
225 	.probe = hyperv_vmbus_probe,
226 	.remove = hyperv_vmbus_remove,
227 	.shutdown = hyperv_vmbus_shutdown,
228 	.suspend = hyperv_vmbus_suspend,
229 	.resume = hyperv_vmbus_resume,
230 	.driver = {
231 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
232 	},
233 };
234 
hyperv_init(void)235 static int __init hyperv_init(void)
236 {
237 	int ret;
238 
239 	if (drm_firmware_drivers_only())
240 		return -ENODEV;
241 
242 	ret = pci_register_driver(&hyperv_pci_driver);
243 	if (ret != 0)
244 		return ret;
245 
246 	return vmbus_driver_register(&hyperv_hv_driver);
247 }
248 
hyperv_exit(void)249 static void __exit hyperv_exit(void)
250 {
251 	vmbus_driver_unregister(&hyperv_hv_driver);
252 	pci_unregister_driver(&hyperv_pci_driver);
253 }
254 
255 module_init(hyperv_init);
256 module_exit(hyperv_exit);
257 
258 MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl);
259 MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl);
260 MODULE_LICENSE("GPL");
261 MODULE_AUTHOR("Deepak Rawat <drawat.floss@gmail.com>");
262 MODULE_DESCRIPTION("DRM driver for Hyper-V synthetic video device");
263