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	drm_aperture_remove_conflicting_framebuffers(screen_info.lfb_base,
 76						     screen_info.lfb_size,
 77						     false,
 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 int 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	return 0;
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	.suspend = hyperv_vmbus_suspend,
226	.resume = hyperv_vmbus_resume,
227	.driver = {
228		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
229	},
230};
231
232static int __init hyperv_init(void)
233{
234	int ret;
235
236	if (drm_firmware_drivers_only())
237		return -ENODEV;
238
239	ret = pci_register_driver(&hyperv_pci_driver);
240	if (ret != 0)
241		return ret;
242
243	return vmbus_driver_register(&hyperv_hv_driver);
244}
245
246static void __exit hyperv_exit(void)
247{
248	vmbus_driver_unregister(&hyperv_hv_driver);
249	pci_unregister_driver(&hyperv_pci_driver);
250}
251
252module_init(hyperv_init);
253module_exit(hyperv_exit);
254
255MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl);
256MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl);
257MODULE_LICENSE("GPL");
258MODULE_AUTHOR("Deepak Rawat <drawat.floss@gmail.com>");
259MODULE_DESCRIPTION("DRM driver for Hyper-V synthetic video device");