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         bo = drv_bo_create(drv_, descriptor->width, descriptor->height, resolved_format,
 101                            descriptor->use_flags);
 102         if (!bo) {
 103                 cros_gralloc_error("Failed to create bo.");
 104                 return -ENOMEM;
 105         }
 106
 107         /*
 108          * If there is a desire for more than one kernel buffer, this can be
 109          * removed once the ArcCodec and Wayland service have the ability to
 110          * send more than one fd. GL/Vulkan drivers may also have to modified.
 111          */
 112         if (drv_num_buffers_per_bo(bo) != 1) {
 113                 drv_bo_destroy(bo);
 114                 cros_gralloc_error("Can only support one buffer per bo.");
 115                 return -EINVAL;
 116         }
 117
 118         hnd = new cros_gralloc_handle();
 119         num_planes = drv_bo_get_num_planes(bo);
 120
 121         hnd->base.version = sizeof(hnd->base);
 122         hnd->base.numFds = num_planes;
 123         hnd->base.numInts = handle_data_size - num_planes;
 124
 125         for (size_t plane = 0; plane < num_planes; plane++) {
 126                 hnd->fds[plane] = drv_bo_get_plane_fd(bo, plane);
 127                 hnd->strides[plane] = drv_bo_get_plane_stride(bo, plane);
 128                 hnd->offsets[plane] = drv_bo_get_plane_offset(bo, plane);
 129                 hnd->sizes[plane] = drv_bo_get_plane_size(bo, plane);
 130
 131                 mod = drv_bo_get_plane_format_modifier(bo, plane);
 132                 hnd->format_modifiers[2 * plane] = static_cast<uint32_t>(mod >> 32);
 133                 hnd->format_modifiers[2 * plane + 1] = static_cast<uint32_t>(mod);
 134         }
 135
 136         hnd->width = drv_bo_get_width(bo);
 137         hnd->height = drv_bo_get_height(bo);
 138         hnd->format = drv_bo_get_format(bo);
 139         hnd->use_flags[0] = static_cast<uint32_t>(descriptor->use_flags >> 32);
 140         hnd->use_flags[1] = static_cast<uint32_t>(descriptor->use_flags);
 141         hnd->pixel_stride = drv_bo_get_stride_in_pixels(bo);
 142         hnd->magic = cros_gralloc_magic;
 143         int32_t format = i915_private_invert_format(hnd->format);
 144         if (format == 0) {
 145                 format =  descriptor->droid_format;
 146         }
 147         hnd->droid_format = format;
 148         hnd->usage = descriptor->producer_usage;
 149         hnd->producer_usage = descriptor->producer_usage;
 150         hnd->consumer_usage = descriptor->consumer_usage;
 151
 152         id = drv_bo_get_plane_handle(bo, 0).u32;
 153         auto buffer = new cros_gralloc_buffer(id, bo, hnd);
 154
 155         SCOPED_SPIN_LOCK(mutex_);
 156         buffers_.emplace(id, buffer);
 157         handles_.emplace(hnd, std::make_pair(buffer, 1));
 158         *out_handle = &hnd->base;
 159         return 0;
 160 }
 161
 162 int32_t cros_gralloc_driver::retain(buffer_handle_t handle)
 163 {
 164         uint32_t id;
 165         SCOPED_SPIN_LOCK(mutex_);
 166
 167         auto hnd = cros_gralloc_convert_handle(handle);
 168         if (!hnd) {
 169                 cros_gralloc_error("Invalid handle.");
 170                 return -EINVAL;
 171         }
 172
 173         auto buffer = get_buffer(hnd);
 174         if (buffer) {
 175                 handles_[hnd].second++;
 176                 buffer->increase_refcount();
 177                 return 0;
 178         }
 179
 180         if (drmPrimeFDToHandle(drv_get_fd(drv_), hnd->fds[0], &id)) {
 181                 cros_gralloc_error("drmPrimeFDToHandle failed.");
 182                 return -errno;
 183         }
 184
 185         if (buffers_.count(id)) {
 186                 buffer = buffers_[id];
 187                 buffer->increase_refcount();
 188         } else {
 189                 struct bo *bo;
 190                 struct drv_import_fd_data data;
 191                 data.format = hnd->format;
 192                 data.width = hnd->width;
 193                 data.height = hnd->height;
 194                 data.use_flags = static_cast<uint64_t>(hnd->use_flags[0]) << 32;
 195                 data.use_flags |= hnd->use_flags[1];
 196
 197                 memcpy(data.fds, hnd->fds, sizeof(data.fds));
 198                 memcpy(data.strides, hnd->strides, sizeof(data.strides));
 199                 memcpy(data.offsets, hnd->offsets, sizeof(data.offsets));
 200                 for (uint32_t plane = 0; plane < DRV_MAX_PLANES; plane++) {
 201                         data.format_modifiers[plane] =
 202                             static_cast<uint64_t>(hnd->format_modifiers[2 * plane]) << 32;
 203                         data.format_modifiers[plane] |= hnd->format_modifiers[2 * plane + 1];
 204                 }
 205
 206                 bo = drv_bo_import(drv_, &data);
 207                 if (!bo)
 208                         return -EFAULT;
 209
 210                 id = drv_bo_get_plane_handle(bo, 0).u32;
 211
 212                 buffer = new cros_gralloc_buffer(id, bo, nullptr);
 213                 buffers_.emplace(id, buffer);
 214         }
 215
 216         handles_.emplace(hnd, std::make_pair(buffer, 1));
 217         return 0;
 218 }
 219
 220 int32_t cros_gralloc_driver::release(buffer_handle_t handle)
 221 {
 222         SCOPED_SPIN_LOCK(mutex_);
 223
 224         auto hnd = cros_gralloc_convert_handle(handle);
 225         if (!hnd) {
 226                 cros_gralloc_error("Invalid handle.");
 227                 return -EINVAL;
 228         }
 229
 230         auto buffer = get_buffer(hnd);
 231         if (!buffer) {
 232                 cros_gralloc_error("Invalid Reference.");
 233                 return -EINVAL;
 234         }
 235
 236         if (!--handles_[hnd].second)
 237                 handles_.erase(hnd);
 238
 239         if (buffer->decrease_refcount() == 0) {
 240                 buffers_.erase(buffer->get_id());
 241                 delete buffer;
 242         }
 243
 244         return 0;
 245 }
 246
 247 int32_t cros_gralloc_driver::lock(buffer_handle_t handle, int32_t acquire_fence, uint32_t map_flags,
 248                                   uint8_t *addr[DRV_MAX_PLANES])
 249 {
 250         int32_t ret = cros_gralloc_sync_wait(acquire_fence);
 251         if (ret)
 252                 return ret;
 253
 254         SCOPED_SPIN_LOCK(mutex_);
 255         auto hnd = cros_gralloc_convert_handle(handle);
 256         if (!hnd) {
 257                 cros_gralloc_error("Invalid handle.");
 258                 return -EINVAL;
 259         }
 260
 261         auto buffer = get_buffer(hnd);
 262         if (!buffer) {
 263                 cros_gralloc_error("Invalid Reference.");
 264                 return -EINVAL;
 265         }
 266
 267         return buffer->lock(map_flags, addr);
 268 }
 269
 270 int32_t cros_gralloc_driver::unlock(buffer_handle_t handle, int32_t *release_fence)
 271 {
 272         SCOPED_SPIN_LOCK(mutex_);;
 273
 274         auto hnd = cros_gralloc_convert_handle(handle);
 275         if (!hnd) {
 276                 cros_gralloc_error("Invalid handle.");
 277                 return -EINVAL;
 278         }
 279
 280         auto buffer = get_buffer(hnd);
 281         if (!buffer) {
 282                 cros_gralloc_error("Invalid Reference.");
 283                 return -EINVAL;
 284         }
 285
 286         /*
 287          * From the ANativeWindow::dequeueBuffer documentation:
 288          *
 289          * "A value of -1 indicates that the caller may access the buffer immediately without
 290          * waiting on a fence."
 291          */
 292         *release_fence = -1;
 293         return buffer->unlock();
 294 }
 295
 296 int32_t cros_gralloc_driver::get_backing_store(buffer_handle_t handle, uint64_t *out_store)
 297 {
 298         SCOPED_SPIN_LOCK(mutex_);
 299
 300         auto hnd = cros_gralloc_convert_handle(handle);
 301         if (!hnd) {
 302                 cros_gralloc_error("Invalid handle.");
 303                 return -EINVAL;
 304         }
 305
 306         auto buffer = get_buffer(hnd);
 307         if (!buffer) {
 308                 cros_gralloc_error("Invalid Reference.");
 309                 return -EINVAL;
 310         }
 311
 312         *out_store = static_cast<uint64_t>(buffer->get_id());
 313         return 0;
 314 }
 315
 316 cros_gralloc_buffer *cros_gralloc_driver::get_buffer(cros_gralloc_handle_t hnd)
 317 {
 318         /* Assumes driver mutex is held. */
 319         if (handles_.count(hnd))
 320                 return handles_[hnd].first;
 321
 322         return nullptr;
 323 }