drivers/gpu/drm/i915/i915_vgpu.c

   1 /*
   2  * Copyright(c) 2011-2015 Intel Corporation. All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #include "i915_vgpu.h"
  25
  26 /**
  27  * DOC: Intel GVT-g guest support
  28  *
  29  * Intel GVT-g is a graphics virtualization technology which shares the
  30  * GPU among multiple virtual machines on a time-sharing basis. Each
  31  * virtual machine is presented a virtual GPU (vGPU), which has equivalent
  32  * features as the underlying physical GPU (pGPU), so i915 driver can run
  33  * seamlessly in a virtual machine. This file provides vGPU specific
  34  * optimizations when running in a virtual machine, to reduce the complexity
  35  * of vGPU emulation and to improve the overall performance.
  36  *
  37  * A primary function introduced here is so-called "address space ballooning"
  38  * technique. Intel GVT-g partitions global graphics memory among multiple VMs,
  39  * so each VM can directly access a portion of the memory without hypervisor's
  40  * intervention, e.g. filling textures or queuing commands. However with the
  41  * partitioning an unmodified i915 driver would assume a smaller graphics
  42  * memory starting from address ZERO, then requires vGPU emulation module to
  43  * translate the graphics address between 'guest view' and 'host view', for
  44  * all registers and command opcodes which contain a graphics memory address.
  45  * To reduce the complexity, Intel GVT-g introduces "address space ballooning",
  46  * by telling the exact partitioning knowledge to each guest i915 driver, which
  47  * then reserves and prevents non-allocated portions from allocation. Thus vGPU
  48  * emulation module only needs to scan and validate graphics addresses without
  49  * complexity of address translation.
  50  *
  51  */
  52
  53 /**
  54  * i915_detect_vgpu - detect virtual GPU
  55  * @dev_priv: i915 device private
  56  *
  57  * This function is called at the initialization stage, to detect whether
  58  * running on a vGPU.
  59  */
  60 void i915_detect_vgpu(struct drm_i915_private *dev_priv)
  61 {
  62         struct pci_dev *pdev = dev_priv->drm.pdev;
  63         u64 magic;
  64         u16 version_major;
  65         void __iomem *shared_area;
  66
  67         BUILD_BUG_ON(sizeof(struct vgt_if) != VGT_PVINFO_SIZE);
  68
  69         /*
  70          * This is called before we setup the main MMIO BAR mappings used via
  71          * the uncore structure, so we need to access the BAR directly. Since
  72          * we do not support VGT on older gens, return early so we don't have
  73          * to consider differently numbered or sized MMIO bars
  74          */
  75         if (INTEL_GEN(dev_priv) < 6)
  76                 return;
  77
  78         shared_area = pci_iomap_range(pdev, 0, VGT_PVINFO_PAGE, VGT_PVINFO_SIZE);
  79         if (!shared_area) {
  80                 DRM_ERROR("failed to map MMIO bar to check for VGT\n");
  81                 return;
  82         }
  83
  84         magic = readq(shared_area + vgtif_offset(magic));
  85         if (magic != VGT_MAGIC)
  86                 goto out;
  87
  88         version_major = readw(shared_area + vgtif_offset(version_major));
  89         if (version_major < VGT_VERSION_MAJOR) {
  90                 DRM_INFO("VGT interface version mismatch!\n");
  91                 goto out;
  92         }
  93
  94         dev_priv->vgpu.caps = readl(shared_area + vgtif_offset(vgt_caps));
  95
  96         dev_priv->vgpu.active = true;
  97         DRM_INFO("Virtual GPU for Intel GVT-g detected.\n");
  98
  99 out:
 100         pci_iounmap(pdev, shared_area);
 101 }
 102
 103 bool intel_vgpu_has_full_ppgtt(struct drm_i915_private *dev_priv)
 104 {
 105         return dev_priv->vgpu.caps & VGT_CAPS_FULL_PPGTT;
 106 }
 107
 108 struct _balloon_info_ {
 109         /*
 110          * There are up to 2 regions per mappable/unmappable graphic
 111          * memory that might be ballooned. Here, index 0/1 is for mappable
 112          * graphic memory, 2/3 for unmappable graphic memory.
 113          */
 114         struct drm_mm_node space[4];
 115 };
 116
 117 static struct _balloon_info_ bl_info;
 118
 119 static void vgt_deballoon_space(struct i915_ggtt *ggtt,
 120                                 struct drm_mm_node *node)
 121 {
 122         DRM_DEBUG_DRIVER("deballoon space: range [0x%llx - 0x%llx] %llu KiB.\n",
 123                          node->start,
 124                          node->start + node->size,
 125                          node->size / 1024);
 126
 127         ggtt->vm.reserved -= node->size;
 128         drm_mm_remove_node(node);
 129 }
 130
 131 /**
 132  * intel_vgt_deballoon - deballoon reserved graphics address trunks
 133  * @ggtt: the global GGTT from which we reserved earlier
 134  *
 135  * This function is called to deallocate the ballooned-out graphic memory, when
 136  * driver is unloaded or when ballooning fails.
 137  */
 138 void intel_vgt_deballoon(struct i915_ggtt *ggtt)
 139 {
 140         int i;
 141
 142         if (!intel_vgpu_active(ggtt->vm.i915))
 143                 return;
 144
 145         DRM_DEBUG("VGT deballoon.\n");
 146
 147         for (i = 0; i < 4; i++)
 148                 vgt_deballoon_space(ggtt, &bl_info.space[i]);
 149 }
 150
 151 static int vgt_balloon_space(struct i915_ggtt *ggtt,
 152                              struct drm_mm_node *node,
 153                              unsigned long start, unsigned long end)
 154 {
 155         unsigned long size = end - start;
 156         int ret;
 157
 158         if (start >= end)
 159                 return -EINVAL;
 160
 161         DRM_INFO("balloon space: range [ 0x%lx - 0x%lx ] %lu KiB.\n",
 162                  start, end, size / 1024);
 163         ret = i915_gem_gtt_reserve(&ggtt->vm, node,
 164                                    size, start, I915_COLOR_UNEVICTABLE,
 165                                    0);
 166         if (!ret)
 167                 ggtt->vm.reserved += size;
 168
 169         return ret;
 170 }
 171
 172 /**
 173  * intel_vgt_balloon - balloon out reserved graphics address trunks
 174  * @ggtt: the global GGTT from which to reserve
 175  *
 176  * This function is called at the initialization stage, to balloon out the
 177  * graphic address space allocated to other vGPUs, by marking these spaces as
 178  * reserved. The ballooning related knowledge(starting address and size of
 179  * the mappable/unmappable graphic memory) is described in the vgt_if structure
 180  * in a reserved mmio range.
 181  *
 182  * To give an example, the drawing below depicts one typical scenario after
 183  * ballooning. Here the vGPU1 has 2 pieces of graphic address spaces ballooned
 184  * out each for the mappable and the non-mappable part. From the vGPU1 point of
 185  * view, the total size is the same as the physical one, with the start address
 186  * of its graphic space being zero. Yet there are some portions ballooned out(
 187  * the shadow part, which are marked as reserved by drm allocator). From the
 188  * host point of view, the graphic address space is partitioned by multiple
 189  * vGPUs in different VMs. ::
 190  *
 191  *                         vGPU1 view         Host view
 192  *              0 ------> +-----------+     +-----------+
 193  *                ^       |###########|     |   vGPU3   |
 194  *                |       |###########|     +-----------+
 195  *                |       |###########|     |   vGPU2   |
 196  *                |       +-----------+     +-----------+
 197  *         mappable GM    | available | ==> |   vGPU1   |
 198  *                |       +-----------+     +-----------+
 199  *                |       |###########|     |           |
 200  *                v       |###########|     |   Host    |
 201  *                +=======+===========+     +===========+
 202  *                ^       |###########|     |   vGPU3   |
 203  *                |       |###########|     +-----------+
 204  *                |       |###########|     |   vGPU2   |
 205  *                |       +-----------+     +-----------+
 206  *       unmappable GM    | available | ==> |   vGPU1   |
 207  *                |       +-----------+     +-----------+
 208  *                |       |###########|     |           |
 209  *                |       |###########|     |   Host    |
 210  *                v       |###########|     |           |
 211  *  total GM size ------> +-----------+     +-----------+
 212  *
 213  * Returns:
 214  * zero on success, non-zero if configuration invalid or ballooning failed
 215  */
 216 int intel_vgt_balloon(struct i915_ggtt *ggtt)
 217 {
 218         struct intel_uncore *uncore = &ggtt->vm.i915->uncore;
 219         unsigned long ggtt_end = ggtt->vm.total;
 220
 221         unsigned long mappable_base, mappable_size, mappable_end;
 222         unsigned long unmappable_base, unmappable_size, unmappable_end;
 223         int ret;
 224
 225         if (!intel_vgpu_active(ggtt->vm.i915))
 226                 return 0;
 227
 228         mappable_base =
 229           intel_uncore_read(uncore, vgtif_reg(avail_rs.mappable_gmadr.base));
 230         mappable_size =
 231           intel_uncore_read(uncore, vgtif_reg(avail_rs.mappable_gmadr.size));
 232         unmappable_base =
 233           intel_uncore_read(uncore, vgtif_reg(avail_rs.nonmappable_gmadr.base));
 234         unmappable_size =
 235           intel_uncore_read(uncore, vgtif_reg(avail_rs.nonmappable_gmadr.size));
 236
 237         mappable_end = mappable_base + mappable_size;
 238         unmappable_end = unmappable_base + unmappable_size;
 239
 240         DRM_INFO("VGT ballooning configuration:\n");
 241         DRM_INFO("Mappable graphic memory: base 0x%lx size %ldKiB\n",
 242                  mappable_base, mappable_size / 1024);
 243         DRM_INFO("Unmappable graphic memory: base 0x%lx size %ldKiB\n",
 244                  unmappable_base, unmappable_size / 1024);
 245
 246         if (mappable_end > ggtt->mappable_end ||
 247             unmappable_base < ggtt->mappable_end ||
 248             unmappable_end > ggtt_end) {
 249                 DRM_ERROR("Invalid ballooning configuration!\n");
 250                 return -EINVAL;
 251         }
 252
 253         /* Unmappable graphic memory ballooning */
 254         if (unmappable_base > ggtt->mappable_end) {
 255                 ret = vgt_balloon_space(ggtt, &bl_info.space[2],
 256                                         ggtt->mappable_end, unmappable_base);
 257
 258                 if (ret)
 259                         goto err;
 260         }
 261
 262         if (unmappable_end < ggtt_end) {
 263                 ret = vgt_balloon_space(ggtt, &bl_info.space[3],
 264                                         unmappable_end, ggtt_end);
 265                 if (ret)
 266                         goto err_upon_mappable;
 267         }
 268
 269         /* Mappable graphic memory ballooning */
 270         if (mappable_base) {
 271                 ret = vgt_balloon_space(ggtt, &bl_info.space[0],
 272                                         0, mappable_base);
 273
 274                 if (ret)
 275                         goto err_upon_unmappable;
 276         }
 277
 278         if (mappable_end < ggtt->mappable_end) {
 279                 ret = vgt_balloon_space(ggtt, &bl_info.space[1],
 280                                         mappable_end, ggtt->mappable_end);
 281
 282                 if (ret)
 283                         goto err_below_mappable;
 284         }
 285
 286         DRM_INFO("VGT balloon successfully\n");
 287         return 0;
 288
 289 err_below_mappable:
 290         vgt_deballoon_space(ggtt, &bl_info.space[0]);
 291 err_upon_unmappable:
 292         vgt_deballoon_space(ggtt, &bl_info.space[3]);
 293 err_upon_mappable:
 294         vgt_deballoon_space(ggtt, &bl_info.space[2]);
 295 err:
 296         DRM_ERROR("VGT balloon fail\n");
 297         return ret;
 298 }