cros_gralloc/cros_gralloc_driver.cc

   1 /*
   2  * Copyright 2017 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 #include "cros_gralloc_driver.h"
   8 #include "../util.h"
   9
  10 #include "i915_private_android.h"
  11
  12 #include <cstdlib>
  13 #include <fcntl.h>
  14 #include <xf86drm.h>
  15
  16 cros_gralloc_driver::cros_gralloc_driver() : drv_(nullptr)
  17 {
  18 }
  19
  20 cros_gralloc_driver::~cros_gralloc_driver()
  21 {
  22         buffers_.clear();
  23         handles_.clear();
  24
  25         if (drv_) {
  26                 drv_destroy(drv_);
  27                 drv_ = nullptr;
  28         }
  29 }
  30
  31 int32_t cros_gralloc_driver::init()
  32 {
  33         /*
  34          * Create a driver from rendernode while filtering out
  35          * the specified undesired driver.
  36          *
  37          * TODO(gsingh): Enable render nodes on udl/evdi.
  38          */
  39
  40         int fd;
  41         drmVersionPtr version;
  42         char const *str = "%s/renderD%d";
  43         const char *undesired[2] = { "vgem", nullptr };
  44         uint32_t num_nodes = 63;
  45         uint32_t min_node = 128;
  46         uint32_t max_node = (min_node + num_nodes);
  47
  48         for (uint32_t i = 0; i < ARRAY_SIZE(undesired); i++) {
  49                 for (uint32_t j = min_node; j < max_node; j++) {
  50                         char *node;
  51                         if (asprintf(&node, str, DRM_DIR_NAME, j) < 0)
  52                                 continue;
  53
  54                         fd = open(node, O_RDWR, 0);
  55                         free(node);
  56
  57                         if (fd < 0)
  58                                 continue;
  59
  60                         version = drmGetVersion(fd);
  61                         if (!version)
  62                                 continue;
  63
  64                         if (undesired[i] && !strcmp(version->name, undesired[i])) {
  65                                 drmFreeVersion(version);
  66                                 continue;
  67                         }
  68
  69                         drmFreeVersion(version);
  70                         drv_ = drv_create(fd);
  71                         if (drv_)
  72                                 return 0;
  73                 }
  74         }
  75
  76         return -ENODEV;
  77 }
  78
  79 bool cros_gralloc_driver::is_supported(const struct cros_gralloc_buffer_descriptor *descriptor)
  80 {
  81         struct combination *combo;
  82         uint32_t resolved_format;
  83         resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->use_flags);
  84         combo = drv_get_combination(drv_, resolved_format, descriptor->use_flags);
  85         return (combo != nullptr);
  86 }
  87
  88 int32_t cros_gralloc_driver::allocate(const struct cros_gralloc_buffer_descriptor *descriptor,
  89                                       buffer_handle_t *out_handle)
  90 {
  91         uint32_t id;
  92         uint64_t mod;
  93         size_t num_planes;
  94         uint32_t resolved_format;
  95
  96         struct bo *bo;
  97         struct cros_gralloc_handle *hnd;
  98
  99         resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->use_flags);
 100         if (descriptor->modifier == 0) {
 101                 bo = drv_bo_create(drv_, descriptor->width, descriptor->height, resolved_format,
 102                                    descriptor->use_flags);
 103         } else {
 104                 bo = drv_bo_create_with_modifiers(drv_, descriptor->width, descriptor->height,
 105                                                   resolved_format, &descriptor->modifier, 1);
 106         }
 107         if (!bo) {
 108                 cros_gralloc_error("Failed to create bo.");
 109                 return -ENOMEM;
 110         }
 111
 112         /*
 113          * If there is a desire for more than one kernel buffer, this can be
 114          * removed once the ArcCodec and Wayland service have the ability to
 115          * send more than one fd. GL/Vulkan drivers may also have to modified.
 116          */
 117         if (drv_num_buffers_per_bo(bo) != 1) {
 118                 drv_bo_destroy(bo);
 119                 cros_gralloc_error("Can only support one buffer per bo.");
 120                 return -EINVAL;
 121         }
 122
 123         hnd = new cros_gralloc_handle();
 124         num_planes = drv_bo_get_num_planes(bo);
 125
 126         hnd->base.version = sizeof(hnd->base);
 127         hnd->base.numFds = num_planes;
 128         hnd->base.numInts = handle_data_size - num_planes;
 129
 130         for (size_t plane = 0; plane < num_planes; plane++) {
 131                 hnd->fds[plane] = drv_bo_get_plane_fd(bo, plane);
 132                 hnd->strides[plane] = drv_bo_get_plane_stride(bo, plane);
 133                 hnd->offsets[plane] = drv_bo_get_plane_offset(bo, plane);
 134                 hnd->sizes[plane] = drv_bo_get_plane_size(bo, plane);
 135
 136                 mod = drv_bo_get_plane_format_modifier(bo, plane);
 137                 hnd->format_modifiers[2 * plane] = static_cast<uint32_t>(mod >> 32);
 138                 hnd->format_modifiers[2 * plane + 1] = static_cast<uint32_t>(mod);
 139         }
 140
 141         hnd->width = drv_bo_get_width(bo);
 142         hnd->height = drv_bo_get_height(bo);
 143         hnd->format = drv_bo_get_format(bo);
 144         hnd->use_flags[0] = static_cast<uint32_t>(descriptor->use_flags >> 32);
 145         hnd->use_flags[1] = static_cast<uint32_t>(descriptor->use_flags);
 146         hnd->pixel_stride = drv_bo_get_stride_in_pixels(bo);
 147         hnd->magic = cros_gralloc_magic;
 148         int32_t format = i915_private_invert_format(hnd->format);
 149         if (format == 0) {
 150                 format =  descriptor->droid_format;
 151         }
 152         hnd->droid_format = format;
 153         hnd->usage = descriptor->producer_usage;
 154         hnd->producer_usage = descriptor->producer_usage;
 155         hnd->consumer_usage = descriptor->consumer_usage;
 156
 157         id = drv_bo_get_plane_handle(bo, 0).u32;
 158         auto buffer = new cros_gralloc_buffer(id, bo, hnd);
 159
 160         SCOPED_SPIN_LOCK(mutex_);
 161         buffers_.emplace(id, buffer);
 162         handles_.emplace(hnd, std::make_pair(buffer, 1));
 163         *out_handle = &hnd->base;
 164         return 0;
 165 }
 166
 167 int32_t cros_gralloc_driver::retain(buffer_handle_t handle)
 168 {
 169         uint32_t id;
 170         SCOPED_SPIN_LOCK(mutex_);
 171
 172         auto hnd = cros_gralloc_convert_handle(handle);
 173         if (!hnd) {
 174                 cros_gralloc_error("Invalid handle.");
 175                 return -EINVAL;
 176         }
 177
 178         auto buffer = get_buffer(hnd);
 179         if (buffer) {
 180                 handles_[hnd].second++;
 181                 buffer->increase_refcount();
 182                 return 0;
 183         }
 184
 185         if (drmPrimeFDToHandle(drv_get_fd(drv_), hnd->fds[0], &id)) {
 186                 cros_gralloc_error("drmPrimeFDToHandle failed.");
 187                 return -errno;
 188         }
 189
 190         if (buffers_.count(id)) {
 191                 buffer = buffers_[id];
 192                 buffer->increase_refcount();
 193         } else {
 194                 struct bo *bo;
 195                 struct drv_import_fd_data data;
 196                 data.format = hnd->format;
 197                 data.width = hnd->width;
 198                 data.height = hnd->height;
 199                 data.use_flags = static_cast<uint64_t>(hnd->use_flags[0]) << 32;
 200                 data.use_flags |= hnd->use_flags[1];
 201
 202                 memcpy(data.fds, hnd->fds, sizeof(data.fds));
 203                 memcpy(data.strides, hnd->strides, sizeof(data.strides));
 204                 memcpy(data.offsets, hnd->offsets, sizeof(data.offsets));
 205                 for (uint32_t plane = 0; plane < DRV_MAX_PLANES; plane++) {
 206                         data.format_modifiers[plane] =
 207                             static_cast<uint64_t>(hnd->format_modifiers[2 * plane]) << 32;
 208                         data.format_modifiers[plane] |= hnd->format_modifiers[2 * plane + 1];
 209                 }
 210
 211                 bo = drv_bo_import(drv_, &data);
 212                 if (!bo)
 213                         return -EFAULT;
 214
 215                 id = drv_bo_get_plane_handle(bo, 0).u32;
 216
 217                 buffer = new cros_gralloc_buffer(id, bo, nullptr);
 218                 buffers_.emplace(id, buffer);
 219         }
 220
 221         handles_.emplace(hnd, std::make_pair(buffer, 1));
 222         return 0;
 223 }
 224
 225 int32_t cros_gralloc_driver::release(buffer_handle_t handle)
 226 {
 227         SCOPED_SPIN_LOCK(mutex_);
 228
 229         auto hnd = cros_gralloc_convert_handle(handle);
 230         if (!hnd) {
 231                 cros_gralloc_error("Invalid handle.");
 232                 return -EINVAL;
 233         }
 234
 235         auto buffer = get_buffer(hnd);
 236         if (!buffer) {
 237                 cros_gralloc_error("Invalid Reference.");
 238                 return -EINVAL;
 239         }
 240
 241         if (!--handles_[hnd].second)
 242                 handles_.erase(hnd);
 243
 244         if (buffer->decrease_refcount() == 0) {
 245                 buffers_.erase(buffer->get_id());
 246                 delete buffer;
 247         }
 248
 249         return 0;
 250 }
 251
 252 int32_t cros_gralloc_driver::lock(buffer_handle_t handle, int32_t acquire_fence, uint32_t map_flags,
 253                                   uint8_t *addr[DRV_MAX_PLANES])
 254 {
 255         int32_t ret = cros_gralloc_sync_wait(acquire_fence);
 256         if (ret)
 257                 return ret;
 258
 259         SCOPED_SPIN_LOCK(mutex_);
 260         auto hnd = cros_gralloc_convert_handle(handle);
 261         if (!hnd) {
 262                 cros_gralloc_error("Invalid handle.");
 263                 return -EINVAL;
 264         }
 265
 266         auto buffer = get_buffer(hnd);
 267         if (!buffer) {
 268                 cros_gralloc_error("Invalid Reference.");
 269                 return -EINVAL;
 270         }
 271
 272         return buffer->lock(map_flags, addr);
 273 }
 274
 275 int32_t cros_gralloc_driver::unlock(buffer_handle_t handle, int32_t *release_fence)
 276 {
 277         SCOPED_SPIN_LOCK(mutex_);;
 278
 279         auto hnd = cros_gralloc_convert_handle(handle);
 280         if (!hnd) {
 281                 cros_gralloc_error("Invalid handle.");
 282                 return -EINVAL;
 283         }
 284
 285         auto buffer = get_buffer(hnd);
 286         if (!buffer) {
 287                 cros_gralloc_error("Invalid Reference.");
 288                 return -EINVAL;
 289         }
 290
 291         /*
 292          * From the ANativeWindow::dequeueBuffer documentation:
 293          *
 294          * "A value of -1 indicates that the caller may access the buffer immediately without
 295          * waiting on a fence."
 296          */
 297         *release_fence = -1;
 298         return buffer->unlock();
 299 }
 300
 301 int32_t cros_gralloc_driver::get_backing_store(buffer_handle_t handle, uint64_t *out_store)
 302 {
 303         SCOPED_SPIN_LOCK(mutex_);
 304
 305         auto hnd = cros_gralloc_convert_handle(handle);
 306         if (!hnd) {
 307                 cros_gralloc_error("Invalid handle.");
 308                 return -EINVAL;
 309         }
 310
 311         auto buffer = get_buffer(hnd);
 312         if (!buffer) {
 313                 cros_gralloc_error("Invalid Reference.");
 314                 return -EINVAL;
 315         }
 316
 317         *out_store = static_cast<uint64_t>(buffer->get_id());
 318         return 0;
 319 }
 320
 321 cros_gralloc_buffer *cros_gralloc_driver::get_buffer(cros_gralloc_handle_t hnd)
 322 {
 323         /* Assumes driver mutex is held. */
 324         if (handles_.count(hnd))
 325                 return handles_[hnd].first;
 326
 327         return nullptr;
 328 }