i915.c

   1 /*
   2  * Copyright 2014 The Chromium OS Authors. All rights reserved.
   3  * Use of this source code is governed by a BSD-style license that can be
   4  * found in the LICENSE file.
   5  */
   6
   7 #ifdef DRV_I915
   8
   9 #include <errno.h>
  10 #include <string.h>
  11 #include <stdio.h>
  12 #include <sys/mman.h>
  13 #include <xf86drm.h>
  14 #include <i915_drm.h>
  15
  16 #include "drv_priv.h"
  17 #include "helpers.h"
  18 #include "util.h"
  19
  20 static struct supported_combination combos[18] = {
  21         {DRM_FORMAT_ARGB1555, DRM_FORMAT_MOD_NONE,
  22                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  23         {DRM_FORMAT_ABGR8888, DRM_FORMAT_MOD_NONE,
  24                 BO_USE_RENDERING | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  25         {DRM_FORMAT_ABGR8888, DRM_FORMAT_MOD_NONE,
  26                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  27         {DRM_FORMAT_ARGB8888, DRM_FORMAT_MOD_NONE,
  28                 BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  29         {DRM_FORMAT_ARGB8888, DRM_FORMAT_MOD_NONE,
  30                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  31         {DRM_FORMAT_GR88, DRM_FORMAT_MOD_NONE,
  32                 BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  33         {DRM_FORMAT_R8, DRM_FORMAT_MOD_NONE,
  34                 BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  35         {DRM_FORMAT_RGB565, DRM_FORMAT_MOD_NONE,
  36                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  37         {DRM_FORMAT_UYVY, DRM_FORMAT_MOD_NONE,
  38                 BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  39         {DRM_FORMAT_UYVY, DRM_FORMAT_MOD_NONE,
  40                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  41         {DRM_FORMAT_XBGR8888, DRM_FORMAT_MOD_NONE,
  42                 BO_USE_RENDERING | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  43         {DRM_FORMAT_XBGR8888, DRM_FORMAT_MOD_NONE,
  44                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  45         {DRM_FORMAT_XRGB1555, DRM_FORMAT_MOD_NONE,
  46                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  47         {DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE,
  48                 BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  49         {DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE,
  50                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  51         {DRM_FORMAT_YUYV, DRM_FORMAT_MOD_NONE,
  52                 BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN},
  53         {DRM_FORMAT_YUYV, DRM_FORMAT_MOD_NONE,
  54                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  55         {DRM_FORMAT_YVU420, DRM_FORMAT_MOD_NONE,
  56                 BO_USE_RENDERING | BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY},
  57 };
  58
  59 struct i915_device
  60 {
  61         int gen;
  62 };
  63
  64 static int get_gen(int device_id)
  65 {
  66         const uint16_t gen3_ids[] = {0x2582, 0x2592, 0x2772, 0x27A2, 0x27AE,
  67                                      0x29C2, 0x29B2, 0x29D2, 0xA001, 0xA011};
  68         unsigned i;
  69         for(i = 0; i < ARRAY_SIZE(gen3_ids); i++)
  70                 if (gen3_ids[i] == device_id)
  71                         return 3;
  72
  73         return 4;
  74 }
  75
  76 static int i915_init(struct driver *drv)
  77 {
  78         struct i915_device *i915_drv;
  79         drm_i915_getparam_t get_param;
  80         int device_id;
  81         int ret;
  82
  83         i915_drv = (struct i915_device*)malloc(sizeof(*i915_drv));
  84         if (!i915_drv)
  85                 return -1;
  86
  87         memset(&get_param, 0, sizeof(get_param));
  88         get_param.param = I915_PARAM_CHIPSET_ID;
  89         get_param.value = &device_id;
  90         ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GETPARAM, &get_param);
  91         if (ret) {
  92                 fprintf(stderr, "drv: DRM_IOCTL_I915_GETPARAM failed\n");
  93                 free(i915_drv);
  94                 return -1;
  95         }
  96
  97         i915_drv->gen = get_gen(device_id);
  98
  99         drv->priv = i915_drv;
 100
 101         drv_insert_combinations(drv, combos, ARRAY_SIZE(combos));
 102         return drv_add_kms_flags(drv);
 103 }
 104
 105 static void i915_close(struct driver *drv)
 106 {
 107         free(drv->priv);
 108         drv->priv = NULL;
 109 }
 110
 111 static void i915_align_dimensions(struct driver *drv, uint32_t tiling_mode,
 112                                   uint32_t *width, uint32_t *height, int bpp)
 113 {
 114         struct i915_device *i915_drv = (struct i915_device *)drv->priv;
 115         uint32_t width_alignment = 4, height_alignment = 4;
 116
 117         switch (tiling_mode) {
 118         default:
 119         case I915_TILING_NONE:
 120                 width_alignment = 64 / bpp;
 121                 break;
 122
 123         case I915_TILING_X:
 124                 width_alignment = 512 / bpp;
 125                 height_alignment = 8;
 126                 break;
 127
 128         case I915_TILING_Y:
 129                 if (i915_drv->gen == 3) {
 130                         width_alignment = 512 / bpp;
 131                         height_alignment = 8;
 132                 } else  {
 133                         width_alignment = 128 / bpp;
 134                         height_alignment = 32;
 135                 }
 136                 break;
 137         }
 138
 139         if (i915_drv->gen > 3) {
 140                 *width = ALIGN(*width, width_alignment);
 141                 *height = ALIGN(*height, height_alignment);
 142         } else {
 143                 uint32_t w;
 144                 for (w = width_alignment; w < *width;  w <<= 1)
 145                         ;
 146                 *width = w;
 147                 *height = ALIGN(*height, height_alignment);
 148         }
 149 }
 150
 151 static int i915_verify_dimensions(struct driver *drv, uint32_t stride,
 152                                   uint32_t height)
 153 {
 154         struct i915_device *i915_drv = (struct i915_device *)drv->priv;
 155         if (i915_drv->gen <= 3 && stride > 8192)
 156                 return 0;
 157
 158         return 1;
 159 }
 160
 161 static int i915_bo_create(struct bo *bo, uint32_t width, uint32_t height,
 162                           uint32_t format, uint32_t flags)
 163 {
 164         struct driver *drv = bo->drv;
 165         int bpp = drv_stride_from_format(format, 1, 0);
 166         struct drm_i915_gem_create gem_create;
 167         struct drm_i915_gem_set_tiling gem_set_tiling;
 168         uint32_t tiling_mode = I915_TILING_NONE;
 169         size_t plane;
 170         int ret;
 171
 172         if (flags & (BO_USE_CURSOR | BO_USE_LINEAR |
 173                      BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN))
 174                 tiling_mode = I915_TILING_NONE;
 175         else if (flags & BO_USE_SCANOUT)
 176                 tiling_mode = I915_TILING_X;
 177         else
 178                 tiling_mode = I915_TILING_Y;
 179
 180         i915_align_dimensions(drv, tiling_mode, &width, &height, bpp);
 181
 182         drv_bo_from_format(bo, width, height, format);
 183
 184         if (!i915_verify_dimensions(drv, bo->strides[0], height))
 185                 return EINVAL;
 186
 187         memset(&gem_create, 0, sizeof(gem_create));
 188         gem_create.size = bo->total_size;
 189
 190         ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GEM_CREATE, &gem_create);
 191         if (ret) {
 192                 fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_CREATE failed "
 193                                 "(size=%llu)\n", gem_create.size);
 194                 return ret;
 195         }
 196
 197         for (plane = 0; plane < bo->num_planes; plane++)
 198                 bo->handles[plane].u32 = gem_create.handle;
 199
 200         memset(&gem_set_tiling, 0, sizeof(gem_set_tiling));
 201         do {
 202                 gem_set_tiling.handle = bo->handles[0].u32;
 203                 gem_set_tiling.tiling_mode = tiling_mode;
 204                 gem_set_tiling.stride = bo->strides[0];
 205                 ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GEM_SET_TILING,
 206                                &gem_set_tiling);
 207         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 208
 209         if (ret == -1) {
 210                 struct drm_gem_close gem_close;
 211                 gem_close.handle = bo->handles[0].u32;
 212                 fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_SET_TILING failed "
 213                                 "errno=%x (handle=%x, tiling=%x, stride=%x)\n",
 214                                 errno,
 215                                 gem_set_tiling.handle,
 216                                 gem_set_tiling.tiling_mode,
 217                                 gem_set_tiling.stride);
 218                 drmIoctl(drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
 219                 return -errno;
 220         }
 221
 222         return 0;
 223 }
 224
 225 static void *i915_bo_map(struct bo *bo, struct map_info *data, size_t plane)
 226 {
 227         int ret;
 228         struct drm_i915_gem_mmap_gtt gem_map;
 229
 230         memset(&gem_map, 0, sizeof(gem_map));
 231         gem_map.handle = bo->handles[0].u32;
 232
 233         ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_MMAP_GTT, &gem_map);
 234         if (ret) {
 235                 fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_MMAP_GTT failed\n");
 236                 return MAP_FAILED;
 237         }
 238
 239         data->length = bo->total_size;
 240
 241         return mmap(0, bo->total_size, PROT_READ | PROT_WRITE, MAP_SHARED,
 242                     bo->drv->fd, gem_map.offset);
 243 }
 244
 245 static uint32_t i915_resolve_format(uint32_t format)
 246 {
 247         switch (format) {
 248         case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
 249                 /*HACK: See b/28671744 */
 250                 return DRM_FORMAT_XBGR8888;
 251         case DRM_FORMAT_FLEX_YCbCr_420_888:
 252                 return DRM_FORMAT_YVU420;
 253         default:
 254                 return format;
 255         }
 256 }
 257
 258 struct backend backend_i915 =
 259 {
 260         .name = "i915",
 261         .init = i915_init,
 262         .close = i915_close,
 263         .bo_create = i915_bo_create,
 264         .bo_destroy = drv_gem_bo_destroy,
 265         .bo_import = drv_prime_bo_import,
 266         .bo_map = i915_bo_map,
 267         .resolve_format = i915_resolve_format,
 268 };
 269
 270 #endif