drivers/gpu/drm/i915/i915_gem_tiling.c

   1 /*
   2  * Copyright © 2008 Intel Corporation
   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
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Eric Anholt <eric@anholt.net>
  25  *
  26  */
  27
  28 #include <linux/string.h>
  29 #include <linux/bitops.h>
  30 #include <drm/drmP.h>
  31 #include <drm/i915_drm.h>
  32 #include "i915_drv.h"
  33
  34 /**
  35  * DOC: buffer object tiling
  36  *
  37  * i915_gem_set_tiling() and i915_gem_get_tiling() is the userspace interface to
  38  * declare fence register requirements.
  39  *
  40  * In principle GEM doesn't care at all about the internal data layout of an
  41  * object, and hence it also doesn't care about tiling or swizzling. There's two
  42  * exceptions:
  43  *
  44  * - For X and Y tiling the hardware provides detilers for CPU access, so called
  45  *   fences. Since there's only a limited amount of them the kernel must manage
  46  *   these, and therefore userspace must tell the kernel the object tiling if it
  47  *   wants to use fences for detiling.
  48  * - On gen3 and gen4 platforms have a swizzling pattern for tiled objects which
  49  *   depends upon the physical page frame number. When swapping such objects the
  50  *   page frame number might change and the kernel must be able to fix this up
  51  *   and hence now the tiling. Note that on a subset of platforms with
  52  *   asymmetric memory channel population the swizzling pattern changes in an
  53  *   unknown way, and for those the kernel simply forbids swapping completely.
  54  *
  55  * Since neither of this applies for new tiling layouts on modern platforms like
  56  * W, Ys and Yf tiling GEM only allows object tiling to be set to X or Y tiled.
  57  * Anything else can be handled in userspace entirely without the kernel's
  58  * invovlement.
  59  */
  60
  61 /* Check pitch constriants for all chips & tiling formats */
  62 static bool
  63 i915_tiling_ok(struct drm_device *dev, int stride, int size, int tiling_mode)
  64 {
  65         int tile_width;
  66
  67         /* Linear is always fine */
  68         if (tiling_mode == I915_TILING_NONE)
  69                 return true;
  70
  71         if (IS_GEN2(dev) ||
  72             (tiling_mode == I915_TILING_Y && HAS_128_BYTE_Y_TILING(dev)))
  73                 tile_width = 128;
  74         else
  75                 tile_width = 512;
  76
  77         /* check maximum stride & object size */
  78         /* i965+ stores the end address of the gtt mapping in the fence
  79          * reg, so dont bother to check the size */
  80         if (INTEL_INFO(dev)->gen >= 7) {
  81                 if (stride / 128 > GEN7_FENCE_MAX_PITCH_VAL)
  82                         return false;
  83         } else if (INTEL_INFO(dev)->gen >= 4) {
  84                 if (stride / 128 > I965_FENCE_MAX_PITCH_VAL)
  85                         return false;
  86         } else {
  87                 if (stride > 8192)
  88                         return false;
  89
  90                 if (IS_GEN3(dev)) {
  91                         if (size > I830_FENCE_MAX_SIZE_VAL << 20)
  92                                 return false;
  93                 } else {
  94                         if (size > I830_FENCE_MAX_SIZE_VAL << 19)
  95                                 return false;
  96                 }
  97         }
  98
  99         if (stride < tile_width)
 100                 return false;
 101
 102         /* 965+ just needs multiples of tile width */
 103         if (INTEL_INFO(dev)->gen >= 4) {
 104                 if (stride & (tile_width - 1))
 105                         return false;
 106                 return true;
 107         }
 108
 109         /* Pre-965 needs power of two tile widths */
 110         if (stride & (stride - 1))
 111                 return false;
 112
 113         return true;
 114 }
 115
 116 /* Is the current GTT allocation valid for the change in tiling? */
 117 static bool
 118 i915_gem_object_fence_ok(struct drm_i915_gem_object *obj, int tiling_mode)
 119 {
 120         struct drm_i915_private *dev_priv = to_i915(obj->base.dev);
 121         u32 size;
 122
 123         if (tiling_mode == I915_TILING_NONE)
 124                 return true;
 125
 126         if (INTEL_GEN(dev_priv) >= 4)
 127                 return true;
 128
 129         if (IS_GEN3(dev_priv)) {
 130                 if (i915_gem_obj_ggtt_offset(obj) & ~I915_FENCE_START_MASK)
 131                         return false;
 132         } else {
 133                 if (i915_gem_obj_ggtt_offset(obj) & ~I830_FENCE_START_MASK)
 134                         return false;
 135         }
 136
 137         size = i915_gem_get_ggtt_size(dev_priv, obj->base.size, tiling_mode);
 138         if (i915_gem_obj_ggtt_size(obj) != size)
 139                 return false;
 140
 141         if (i915_gem_obj_ggtt_offset(obj) & (size - 1))
 142                 return false;
 143
 144         return true;
 145 }
 146
 147 /**
 148  * i915_gem_set_tiling - IOCTL handler to set tiling mode
 149  * @dev: DRM device
 150  * @data: data pointer for the ioctl
 151  * @file: DRM file for the ioctl call
 152  *
 153  * Sets the tiling mode of an object, returning the required swizzling of
 154  * bit 6 of addresses in the object.
 155  *
 156  * Called by the user via ioctl.
 157  *
 158  * Returns:
 159  * Zero on success, negative errno on failure.
 160  */
 161 int
 162 i915_gem_set_tiling(struct drm_device *dev, void *data,
 163                    struct drm_file *file)
 164 {
 165         struct drm_i915_gem_set_tiling *args = data;
 166         struct drm_i915_private *dev_priv = to_i915(dev);
 167         struct drm_i915_gem_object *obj;
 168         int ret = 0;
 169
 170         obj = i915_gem_object_lookup(file, args->handle);
 171         if (!obj)
 172                 return -ENOENT;
 173
 174         if (!i915_tiling_ok(dev,
 175                             args->stride, obj->base.size, args->tiling_mode)) {
 176                 i915_gem_object_put_unlocked(obj);
 177                 return -EINVAL;
 178         }
 179
 180         intel_runtime_pm_get(dev_priv);
 181
 182         mutex_lock(&dev->struct_mutex);
 183         if (obj->pin_display || obj->framebuffer_references) {
 184                 ret = -EBUSY;
 185                 goto err;
 186         }
 187
 188         if (args->tiling_mode == I915_TILING_NONE) {
 189                 args->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 190                 args->stride = 0;
 191         } else {
 192                 if (args->tiling_mode == I915_TILING_X)
 193                         args->swizzle_mode = dev_priv->mm.bit_6_swizzle_x;
 194                 else
 195                         args->swizzle_mode = dev_priv->mm.bit_6_swizzle_y;
 196
 197                 /* Hide bit 17 swizzling from the user.  This prevents old Mesa
 198                  * from aborting the application on sw fallbacks to bit 17,
 199                  * and we use the pread/pwrite bit17 paths to swizzle for it.
 200                  * If there was a user that was relying on the swizzle
 201                  * information for drm_intel_bo_map()ed reads/writes this would
 202                  * break it, but we don't have any of those.
 203                  */
 204                 if (args->swizzle_mode == I915_BIT_6_SWIZZLE_9_17)
 205                         args->swizzle_mode = I915_BIT_6_SWIZZLE_9;
 206                 if (args->swizzle_mode == I915_BIT_6_SWIZZLE_9_10_17)
 207                         args->swizzle_mode = I915_BIT_6_SWIZZLE_9_10;
 208
 209                 /* If we can't handle the swizzling, make it untiled. */
 210                 if (args->swizzle_mode == I915_BIT_6_SWIZZLE_UNKNOWN) {
 211                         args->tiling_mode = I915_TILING_NONE;
 212                         args->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 213                         args->stride = 0;
 214                 }
 215         }
 216
 217         if (args->tiling_mode != obj->tiling_mode ||
 218             args->stride != obj->stride) {
 219                 /* We need to rebind the object if its current allocation
 220                  * no longer meets the alignment restrictions for its new
 221                  * tiling mode. Otherwise we can just leave it alone, but
 222                  * need to ensure that any fence register is updated before
 223                  * the next fenced (either through the GTT or by the BLT unit
 224                  * on older GPUs) access.
 225                  *
 226                  * After updating the tiling parameters, we then flag whether
 227                  * we need to update an associated fence register. Note this
 228                  * has to also include the unfenced register the GPU uses
 229                  * whilst executing a fenced command for an untiled object.
 230                  */
 231                 if (obj->map_and_fenceable &&
 232                     !i915_gem_object_fence_ok(obj, args->tiling_mode))
 233                         ret = i915_vma_unbind(i915_gem_obj_to_ggtt(obj));
 234
 235                 if (ret == 0) {
 236                         if (obj->pages &&
 237                             obj->madv == I915_MADV_WILLNEED &&
 238                             dev_priv->quirks & QUIRK_PIN_SWIZZLED_PAGES) {
 239                                 if (args->tiling_mode == I915_TILING_NONE)
 240                                         i915_gem_object_unpin_pages(obj);
 241                                 if (obj->tiling_mode == I915_TILING_NONE)
 242                                         i915_gem_object_pin_pages(obj);
 243                         }
 244
 245                         obj->fence_dirty =
 246                                 !i915_gem_active_is_idle(&obj->last_fence,
 247                                                          &dev->struct_mutex) ||
 248                                 obj->fence_reg != I915_FENCE_REG_NONE;
 249
 250                         obj->tiling_mode = args->tiling_mode;
 251                         obj->stride = args->stride;
 252
 253                         /* Force the fence to be reacquired for GTT access */
 254                         i915_gem_release_mmap(obj);
 255                 }
 256         }
 257         /* we have to maintain this existing ABI... */
 258         args->stride = obj->stride;
 259         args->tiling_mode = obj->tiling_mode;
 260
 261         /* Try to preallocate memory required to save swizzling on put-pages */
 262         if (i915_gem_object_needs_bit17_swizzle(obj)) {
 263                 if (obj->bit_17 == NULL) {
 264                         obj->bit_17 = kcalloc(BITS_TO_LONGS(obj->base.size >> PAGE_SHIFT),
 265                                               sizeof(long), GFP_KERNEL);
 266                 }
 267         } else {
 268                 kfree(obj->bit_17);
 269                 obj->bit_17 = NULL;
 270         }
 271
 272 err:
 273         i915_gem_object_put(obj);
 274         mutex_unlock(&dev->struct_mutex);
 275
 276         intel_runtime_pm_put(dev_priv);
 277
 278         return ret;
 279 }
 280
 281 /**
 282  * i915_gem_get_tiling - IOCTL handler to get tiling mode
 283  * @dev: DRM device
 284  * @data: data pointer for the ioctl
 285  * @file: DRM file for the ioctl call
 286  *
 287  * Returns the current tiling mode and required bit 6 swizzling for the object.
 288  *
 289  * Called by the user via ioctl.
 290  *
 291  * Returns:
 292  * Zero on success, negative errno on failure.
 293  */
 294 int
 295 i915_gem_get_tiling(struct drm_device *dev, void *data,
 296                    struct drm_file *file)
 297 {
 298         struct drm_i915_gem_get_tiling *args = data;
 299         struct drm_i915_private *dev_priv = to_i915(dev);
 300         struct drm_i915_gem_object *obj;
 301
 302         obj = i915_gem_object_lookup(file, args->handle);
 303         if (!obj)
 304                 return -ENOENT;
 305
 306         mutex_lock(&dev->struct_mutex);
 307
 308         args->tiling_mode = obj->tiling_mode;
 309         switch (obj->tiling_mode) {
 310         case I915_TILING_X:
 311                 args->swizzle_mode = dev_priv->mm.bit_6_swizzle_x;
 312                 break;
 313         case I915_TILING_Y:
 314                 args->swizzle_mode = dev_priv->mm.bit_6_swizzle_y;
 315                 break;
 316         case I915_TILING_NONE:
 317                 args->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 318                 break;
 319         default:
 320                 DRM_ERROR("unknown tiling mode\n");
 321         }
 322
 323         /* Hide bit 17 from the user -- see comment in i915_gem_set_tiling */
 324         if (dev_priv->quirks & QUIRK_PIN_SWIZZLED_PAGES)
 325                 args->phys_swizzle_mode = I915_BIT_6_SWIZZLE_UNKNOWN;
 326         else
 327                 args->phys_swizzle_mode = args->swizzle_mode;
 328         if (args->swizzle_mode == I915_BIT_6_SWIZZLE_9_17)
 329                 args->swizzle_mode = I915_BIT_6_SWIZZLE_9;
 330         if (args->swizzle_mode == I915_BIT_6_SWIZZLE_9_10_17)
 331                 args->swizzle_mode = I915_BIT_6_SWIZZLE_9_10;
 332
 333         i915_gem_object_put(obj);
 334         mutex_unlock(&dev->struct_mutex);
 335
 336         return 0;
 337 }