drivers/gpu/drm/hyperv/hyperv_drm_drv.c

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