Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Deepak Rawat | 943 | 98.13% | 1 | 14.29% |
Javier Martinez Canillas | 9 | 0.94% | 1 | 14.29% |
Christophe Jaillet | 3 | 0.31% | 1 | 14.29% |
Thomas Zimmermann | 3 | 0.31% | 2 | 28.57% |
Saurabh Sengar | 2 | 0.21% | 1 | 14.29% |
Dawei Li | 1 | 0.10% | 1 | 14.29% |
Total | 961 | 7 |
// SPDX-License-Identifier: GPL-2.0-only /* * Copyright 2021 Microsoft */ #include <linux/efi.h> #include <linux/hyperv.h> #include <linux/module.h> #include <linux/pci.h> #include <drm/drm_aperture.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_drv.h> #include <drm/drm_fbdev_generic.h> #include <drm/drm_gem_shmem_helper.h> #include <drm/drm_simple_kms_helper.h> #include "hyperv_drm.h" #define DRIVER_NAME "hyperv_drm" #define DRIVER_DESC "DRM driver for Hyper-V synthetic video device" #define DRIVER_DATE "2020" #define DRIVER_MAJOR 1 #define DRIVER_MINOR 0 DEFINE_DRM_GEM_FOPS(hv_fops); static struct drm_driver hyperv_driver = { .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC, .name = DRIVER_NAME, .desc = DRIVER_DESC, .date = DRIVER_DATE, .major = DRIVER_MAJOR, .minor = DRIVER_MINOR, .fops = &hv_fops, DRM_GEM_SHMEM_DRIVER_OPS, }; static int hyperv_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { return 0; } static void hyperv_pci_remove(struct pci_dev *pdev) { } static const struct pci_device_id hyperv_pci_tbl[] = { { .vendor = PCI_VENDOR_ID_MICROSOFT, .device = PCI_DEVICE_ID_HYPERV_VIDEO, }, { /* end of list */ } }; /* * PCI stub to support gen1 VM. */ static struct pci_driver hyperv_pci_driver = { .name = KBUILD_MODNAME, .id_table = hyperv_pci_tbl, .probe = hyperv_pci_probe, .remove = hyperv_pci_remove, }; static int hyperv_setup_vram(struct hyperv_drm_device *hv, struct hv_device *hdev) { struct drm_device *dev = &hv->dev; int ret; drm_aperture_remove_conflicting_framebuffers(screen_info.lfb_base, screen_info.lfb_size, false, &hyperv_driver); hv->fb_size = (unsigned long)hv->mmio_megabytes * 1024 * 1024; ret = vmbus_allocate_mmio(&hv->mem, hdev, 0, -1, hv->fb_size, 0x100000, true); if (ret) { drm_err(dev, "Failed to allocate mmio\n"); return -ENOMEM; } /* * Map the VRAM cacheable for performance. This is also required for VM * connect to display properly for ARM64 Linux VM, as the host also maps * the VRAM cacheable. */ hv->vram = ioremap_cache(hv->mem->start, hv->fb_size); if (!hv->vram) { drm_err(dev, "Failed to map vram\n"); ret = -ENOMEM; goto error; } hv->fb_base = hv->mem->start; return 0; error: vmbus_free_mmio(hv->mem->start, hv->fb_size); return ret; } static int hyperv_vmbus_probe(struct hv_device *hdev, const struct hv_vmbus_device_id *dev_id) { struct hyperv_drm_device *hv; struct drm_device *dev; int ret; hv = devm_drm_dev_alloc(&hdev->device, &hyperv_driver, struct hyperv_drm_device, dev); if (IS_ERR(hv)) return PTR_ERR(hv); dev = &hv->dev; init_completion(&hv->wait); hv_set_drvdata(hdev, hv); hv->hdev = hdev; ret = hyperv_connect_vsp(hdev); if (ret) { drm_err(dev, "Failed to connect to vmbus.\n"); goto err_hv_set_drv_data; } ret = hyperv_setup_vram(hv, hdev); if (ret) goto err_vmbus_close; /* * Should be done only once during init and resume. Failing to update * vram location is not fatal. Device will update dirty area till * preferred resolution only. */ ret = hyperv_update_vram_location(hdev, hv->fb_base); if (ret) drm_warn(dev, "Failed to update vram location.\n"); ret = hyperv_mode_config_init(hv); if (ret) goto err_free_mmio; ret = drm_dev_register(dev, 0); if (ret) { drm_err(dev, "Failed to register drm driver.\n"); goto err_free_mmio; } drm_fbdev_generic_setup(dev, 0); return 0; err_free_mmio: vmbus_free_mmio(hv->mem->start, hv->fb_size); err_vmbus_close: vmbus_close(hdev->channel); err_hv_set_drv_data: hv_set_drvdata(hdev, NULL); return ret; } static void hyperv_vmbus_remove(struct hv_device *hdev) { struct drm_device *dev = hv_get_drvdata(hdev); struct hyperv_drm_device *hv = to_hv(dev); drm_dev_unplug(dev); drm_atomic_helper_shutdown(dev); vmbus_close(hdev->channel); hv_set_drvdata(hdev, NULL); vmbus_free_mmio(hv->mem->start, hv->fb_size); } static int hyperv_vmbus_suspend(struct hv_device *hdev) { struct drm_device *dev = hv_get_drvdata(hdev); int ret; ret = drm_mode_config_helper_suspend(dev); if (ret) return ret; vmbus_close(hdev->channel); return 0; } static int hyperv_vmbus_resume(struct hv_device *hdev) { struct drm_device *dev = hv_get_drvdata(hdev); struct hyperv_drm_device *hv = to_hv(dev); int ret; ret = hyperv_connect_vsp(hdev); if (ret) return ret; ret = hyperv_update_vram_location(hdev, hv->fb_base); if (ret) return ret; return drm_mode_config_helper_resume(dev); } static const struct hv_vmbus_device_id hyperv_vmbus_tbl[] = { /* Synthetic Video Device GUID */ {HV_SYNTHVID_GUID}, {} }; static struct hv_driver hyperv_hv_driver = { .name = KBUILD_MODNAME, .id_table = hyperv_vmbus_tbl, .probe = hyperv_vmbus_probe, .remove = hyperv_vmbus_remove, .suspend = hyperv_vmbus_suspend, .resume = hyperv_vmbus_resume, .driver = { .probe_type = PROBE_PREFER_ASYNCHRONOUS, }, }; static int __init hyperv_init(void) { int ret; if (drm_firmware_drivers_only()) return -ENODEV; ret = pci_register_driver(&hyperv_pci_driver); if (ret != 0) return ret; return vmbus_driver_register(&hyperv_hv_driver); } static void __exit hyperv_exit(void) { vmbus_driver_unregister(&hyperv_hv_driver); pci_unregister_driver(&hyperv_pci_driver); } module_init(hyperv_init); module_exit(hyperv_exit); MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl); MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Deepak Rawat <drawat.floss@gmail.com>"); MODULE_DESCRIPTION("DRM driver for Hyper-V synthetic video device");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1