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#include <linux/screen_info.h>
11
12#include <drm/drm_aperture.h>
13#include <drm/drm_atomic_helper.h>
14#include <drm/drm_drv.h>
15#include <drm/drm_fbdev_generic.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_DATE "2020"
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	.date		 = DRIVER_DATE,
35	.major		 = DRIVER_MAJOR,
36	.minor		 = DRIVER_MINOR,
37
38	.fops		 = &hv_fops,
39	DRM_GEM_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	drm_aperture_remove_conflicting_framebuffers(screen_info.lfb_base,
77						     screen_info.lfb_size,
78						     &hyperv_driver);
79
80	hv->fb_size = (unsigned long)hv->mmio_megabytes * 1024 * 1024;
81
82	ret = vmbus_allocate_mmio(&hv->mem, hdev, 0, -1, hv->fb_size, 0x100000,
83				  true);
84	if (ret) {
85		drm_err(dev, "Failed to allocate mmio\n");
86		return -ENOMEM;
87	}
88
89	/*
90	 * Map the VRAM cacheable for performance. This is also required for VM
91	 * connect to display properly for ARM64 Linux VM, as the host also maps
92	 * the VRAM cacheable.
93	 */
94	hv->vram = ioremap_cache(hv->mem->start, hv->fb_size);
95	if (!hv->vram) {
96		drm_err(dev, "Failed to map vram\n");
97		ret = -ENOMEM;
98		goto error;
99	}
100
101	hv->fb_base = hv->mem->start;
102	return 0;
103
104error:
105	vmbus_free_mmio(hv->mem->start, hv->fb_size);
106	return ret;
107}
108
109static int hyperv_vmbus_probe(struct hv_device *hdev,
110			      const struct hv_vmbus_device_id *dev_id)
111{
112	struct hyperv_drm_device *hv;
113	struct drm_device *dev;
114	int ret;
115
116	hv = devm_drm_dev_alloc(&hdev->device, &hyperv_driver,
117				struct hyperv_drm_device, dev);
118	if (IS_ERR(hv))
119		return PTR_ERR(hv);
120
121	dev = &hv->dev;
122	init_completion(&hv->wait);
123	hv_set_drvdata(hdev, hv);
124	hv->hdev = hdev;
125
126	ret = hyperv_connect_vsp(hdev);
127	if (ret) {
128		drm_err(dev, "Failed to connect to vmbus.\n");
129		goto err_hv_set_drv_data;
130	}
131
132	ret = hyperv_setup_vram(hv, hdev);
133	if (ret)
134		goto err_vmbus_close;
135
136	/*
137	 * Should be done only once during init and resume. Failing to update
138	 * vram location is not fatal. Device will update dirty area till
139	 * preferred resolution only.
140	 */
141	ret = hyperv_update_vram_location(hdev, hv->fb_base);
142	if (ret)
143		drm_warn(dev, "Failed to update vram location.\n");
144
145	ret = hyperv_mode_config_init(hv);
146	if (ret)
147		goto err_free_mmio;
148
149	ret = drm_dev_register(dev, 0);
150	if (ret) {
151		drm_err(dev, "Failed to register drm driver.\n");
152		goto err_free_mmio;
153	}
154
155	drm_fbdev_generic_setup(dev, 0);
156
157	return 0;
158
159err_free_mmio:
160	vmbus_free_mmio(hv->mem->start, hv->fb_size);
161err_vmbus_close:
162	vmbus_close(hdev->channel);
163err_hv_set_drv_data:
164	hv_set_drvdata(hdev, NULL);
165	return ret;
166}
167
168static void hyperv_vmbus_remove(struct hv_device *hdev)
169{
170	struct drm_device *dev = hv_get_drvdata(hdev);
171	struct hyperv_drm_device *hv = to_hv(dev);
172
173	drm_dev_unplug(dev);
174	drm_atomic_helper_shutdown(dev);
175	vmbus_close(hdev->channel);
176	hv_set_drvdata(hdev, NULL);
177
178	vmbus_free_mmio(hv->mem->start, hv->fb_size);
179}
180
181static int hyperv_vmbus_suspend(struct hv_device *hdev)
182{
183	struct drm_device *dev = hv_get_drvdata(hdev);
184	int ret;
185
186	ret = drm_mode_config_helper_suspend(dev);
187	if (ret)
188		return ret;
189
190	vmbus_close(hdev->channel);
191
192	return 0;
193}
194
195static int hyperv_vmbus_resume(struct hv_device *hdev)
196{
197	struct drm_device *dev = hv_get_drvdata(hdev);
198	struct hyperv_drm_device *hv = to_hv(dev);
199	int ret;
200
201	ret = hyperv_connect_vsp(hdev);
202	if (ret)
203		return ret;
204
205	ret = hyperv_update_vram_location(hdev, hv->fb_base);
206	if (ret)
207		return ret;
208
209	return drm_mode_config_helper_resume(dev);
210}
211
212static const struct hv_vmbus_device_id hyperv_vmbus_tbl[] = {
213	/* Synthetic Video Device GUID */
214	{HV_SYNTHVID_GUID},
215	{}
216};
217
218static struct hv_driver hyperv_hv_driver = {
219	.name = KBUILD_MODNAME,
220	.id_table = hyperv_vmbus_tbl,
221	.probe = hyperv_vmbus_probe,
222	.remove = hyperv_vmbus_remove,
223	.suspend = hyperv_vmbus_suspend,
224	.resume = hyperv_vmbus_resume,
225	.driver = {
226		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
227	},
228};
229
230static int __init hyperv_init(void)
231{
232	int ret;
233
234	if (drm_firmware_drivers_only())
235		return -ENODEV;
236
237	ret = pci_register_driver(&hyperv_pci_driver);
238	if (ret != 0)
239		return ret;
240
241	return vmbus_driver_register(&hyperv_hv_driver);
242}
243
244static void __exit hyperv_exit(void)
245{
246	vmbus_driver_unregister(&hyperv_hv_driver);
247	pci_unregister_driver(&hyperv_pci_driver);
248}
249
250module_init(hyperv_init);
251module_exit(hyperv_exit);
252
253MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl);
254MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl);
255MODULE_LICENSE("GPL");
256MODULE_AUTHOR("Deepak Rawat <drawat.floss@gmail.com>");
257MODULE_DESCRIPTION("DRM driver for Hyper-V synthetic video device");
258