/*
|
* Copyright 2017 The Chromium OS Authors. All rights reserved.
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#include "cros_gralloc_driver.h"
|
#include "../util.h"
|
|
#include <cstdlib>
|
#include <fcntl.h>
|
#include <xf86drm.h>
|
|
cros_gralloc_driver::cros_gralloc_driver() : drv_(nullptr)
|
{
|
}
|
|
cros_gralloc_driver::~cros_gralloc_driver()
|
{
|
buffers_.clear();
|
handles_.clear();
|
|
if (drv_) {
|
drv_destroy(drv_);
|
drv_ = nullptr;
|
}
|
}
|
|
int32_t cros_gralloc_driver::init()
|
{
|
/*
|
* Create a driver from rendernode while filtering out
|
* the specified undesired driver.
|
*
|
* TODO(gsingh): Enable render nodes on udl/evdi.
|
*/
|
|
int fd;
|
drmVersionPtr version;
|
char const *str = "%s/renderD%d";
|
const char *undesired[2] = { "vgem", nullptr };
|
uint32_t num_nodes = 63;
|
uint32_t min_node = 128;
|
uint32_t max_node = (min_node + num_nodes);
|
|
for (uint32_t i = 0; i < ARRAY_SIZE(undesired); i++) {
|
for (uint32_t j = min_node; j < max_node; j++) {
|
char *node;
|
if (asprintf(&node, str, DRM_DIR_NAME, j) < 0)
|
continue;
|
|
fd = open(node, O_RDWR, 0);
|
free(node);
|
|
if (fd < 0)
|
continue;
|
|
version = drmGetVersion(fd);
|
if (!version)
|
continue;
|
|
if (undesired[i] && !strcmp(version->name, undesired[i])) {
|
drmFreeVersion(version);
|
continue;
|
}
|
|
drmFreeVersion(version);
|
drv_ = drv_create(fd);
|
if (drv_)
|
return 0;
|
}
|
}
|
|
return -ENODEV;
|
}
|
|
bool cros_gralloc_driver::is_supported(const struct cros_gralloc_buffer_descriptor *descriptor)
|
{
|
struct combination *combo;
|
uint32_t resolved_format;
|
resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->use_flags);
|
combo = drv_get_combination(drv_, resolved_format, descriptor->use_flags);
|
return (combo != nullptr);
|
}
|
|
int32_t cros_gralloc_driver::allocate(const struct cros_gralloc_buffer_descriptor *descriptor,
|
buffer_handle_t *out_handle)
|
{
|
uint32_t id;
|
uint64_t mod;
|
size_t num_planes;
|
uint32_t resolved_format;
|
uint32_t bytes_per_pixel;
|
uint64_t use_flags;
|
|
struct bo *bo;
|
struct cros_gralloc_handle *hnd;
|
|
resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->use_flags);
|
use_flags = descriptor->use_flags;
|
/*
|
* TODO(b/79682290): ARC++ assumes NV12 is always linear and doesn't
|
* send modifiers across Wayland protocol, so we or in the
|
* BO_USE_LINEAR flag here. We need to fix ARC++ to allocate and work
|
* with tiled buffers.
|
*/
|
if (resolved_format == DRM_FORMAT_NV12)
|
use_flags |= BO_USE_LINEAR;
|
|
bo = drv_bo_create(drv_, descriptor->width, descriptor->height, resolved_format, use_flags);
|
if (!bo) {
|
drv_log("Failed to create bo.\n");
|
return -ENOMEM;
|
}
|
|
/*
|
* If there is a desire for more than one kernel buffer, this can be
|
* removed once the ArcCodec and Wayland service have the ability to
|
* send more than one fd. GL/Vulkan drivers may also have to modified.
|
*/
|
if (drv_num_buffers_per_bo(bo) != 1) {
|
drv_bo_destroy(bo);
|
drv_log("Can only support one buffer per bo.\n");
|
return -EINVAL;
|
}
|
|
hnd = new cros_gralloc_handle();
|
num_planes = drv_bo_get_num_planes(bo);
|
|
hnd->base.version = sizeof(hnd->base);
|
hnd->base.numFds = num_planes;
|
hnd->base.numInts = handle_data_size - num_planes;
|
|
for (size_t plane = 0; plane < num_planes; plane++) {
|
hnd->fds[plane] = drv_bo_get_plane_fd(bo, plane);
|
hnd->strides[plane] = drv_bo_get_plane_stride(bo, plane);
|
hnd->offsets[plane] = drv_bo_get_plane_offset(bo, plane);
|
|
mod = drv_bo_get_plane_format_modifier(bo, plane);
|
hnd->format_modifiers[2 * plane] = static_cast<uint32_t>(mod >> 32);
|
hnd->format_modifiers[2 * plane + 1] = static_cast<uint32_t>(mod);
|
}
|
|
hnd->width = drv_bo_get_width(bo);
|
hnd->height = drv_bo_get_height(bo);
|
hnd->format = drv_bo_get_format(bo);
|
hnd->use_flags[0] = static_cast<uint32_t>(descriptor->use_flags >> 32);
|
hnd->use_flags[1] = static_cast<uint32_t>(descriptor->use_flags);
|
bytes_per_pixel = drv_bytes_per_pixel_from_format(hnd->format, 0);
|
hnd->pixel_stride = DIV_ROUND_UP(hnd->strides[0], bytes_per_pixel);
|
hnd->magic = cros_gralloc_magic;
|
hnd->droid_format = descriptor->droid_format;
|
hnd->usage = descriptor->producer_usage;
|
|
id = drv_bo_get_plane_handle(bo, 0).u32;
|
auto buffer = new cros_gralloc_buffer(id, bo, hnd);
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
buffers_.emplace(id, buffer);
|
handles_.emplace(hnd, std::make_pair(buffer, 1));
|
*out_handle = &hnd->base;
|
return 0;
|
}
|
|
int32_t cros_gralloc_driver::retain(buffer_handle_t handle)
|
{
|
uint32_t id;
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto hnd = cros_gralloc_convert_handle(handle);
|
if (!hnd) {
|
drv_log("Invalid handle.\n");
|
return -EINVAL;
|
}
|
|
auto buffer = get_buffer(hnd);
|
if (buffer) {
|
handles_[hnd].second++;
|
buffer->increase_refcount();
|
return 0;
|
}
|
|
if (drmPrimeFDToHandle(drv_get_fd(drv_), hnd->fds[0], &id)) {
|
drv_log("drmPrimeFDToHandle failed.\n");
|
return -errno;
|
}
|
|
if (buffers_.count(id)) {
|
buffer = buffers_[id];
|
buffer->increase_refcount();
|
} else {
|
struct bo *bo;
|
struct drv_import_fd_data data;
|
data.format = hnd->format;
|
data.width = hnd->width;
|
data.height = hnd->height;
|
data.use_flags = static_cast<uint64_t>(hnd->use_flags[0]) << 32;
|
data.use_flags |= hnd->use_flags[1];
|
|
memcpy(data.fds, hnd->fds, sizeof(data.fds));
|
memcpy(data.strides, hnd->strides, sizeof(data.strides));
|
memcpy(data.offsets, hnd->offsets, sizeof(data.offsets));
|
for (uint32_t plane = 0; plane < DRV_MAX_PLANES; plane++) {
|
data.format_modifiers[plane] =
|
static_cast<uint64_t>(hnd->format_modifiers[2 * plane]) << 32;
|
data.format_modifiers[plane] |= hnd->format_modifiers[2 * plane + 1];
|
}
|
|
bo = drv_bo_import(drv_, &data);
|
if (!bo)
|
return -EFAULT;
|
|
id = drv_bo_get_plane_handle(bo, 0).u32;
|
|
buffer = new cros_gralloc_buffer(id, bo, nullptr);
|
buffers_.emplace(id, buffer);
|
}
|
|
handles_.emplace(hnd, std::make_pair(buffer, 1));
|
return 0;
|
}
|
|
int32_t cros_gralloc_driver::release(buffer_handle_t handle)
|
{
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto hnd = cros_gralloc_convert_handle(handle);
|
if (!hnd) {
|
drv_log("Invalid handle.\n");
|
return -EINVAL;
|
}
|
|
auto buffer = get_buffer(hnd);
|
if (!buffer) {
|
drv_log("Invalid Reference.\n");
|
return -EINVAL;
|
}
|
|
if (!--handles_[hnd].second)
|
handles_.erase(hnd);
|
|
if (buffer->decrease_refcount() == 0) {
|
buffers_.erase(buffer->get_id());
|
delete buffer;
|
}
|
|
return 0;
|
}
|
|
int32_t cros_gralloc_driver::lock(buffer_handle_t handle, int32_t acquire_fence,
|
const struct rectangle *rect, uint32_t map_flags,
|
uint8_t *addr[DRV_MAX_PLANES])
|
{
|
int32_t ret = cros_gralloc_sync_wait(acquire_fence);
|
if (ret)
|
return ret;
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
auto hnd = cros_gralloc_convert_handle(handle);
|
if (!hnd) {
|
drv_log("Invalid handle.\n");
|
return -EINVAL;
|
}
|
|
auto buffer = get_buffer(hnd);
|
if (!buffer) {
|
drv_log("Invalid Reference.\n");
|
return -EINVAL;
|
}
|
|
return buffer->lock(rect, map_flags, addr);
|
}
|
|
int32_t cros_gralloc_driver::unlock(buffer_handle_t handle, int32_t *release_fence)
|
{
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto hnd = cros_gralloc_convert_handle(handle);
|
if (!hnd) {
|
drv_log("Invalid handle.\n");
|
return -EINVAL;
|
}
|
|
auto buffer = get_buffer(hnd);
|
if (!buffer) {
|
drv_log("Invalid Reference.\n");
|
return -EINVAL;
|
}
|
|
/*
|
* From the ANativeWindow::dequeueBuffer documentation:
|
*
|
* "A value of -1 indicates that the caller may access the buffer immediately without
|
* waiting on a fence."
|
*/
|
*release_fence = -1;
|
return buffer->unlock();
|
}
|
|
int32_t cros_gralloc_driver::get_backing_store(buffer_handle_t handle, uint64_t *out_store)
|
{
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto hnd = cros_gralloc_convert_handle(handle);
|
if (!hnd) {
|
drv_log("Invalid handle.\n");
|
return -EINVAL;
|
}
|
|
auto buffer = get_buffer(hnd);
|
if (!buffer) {
|
drv_log("Invalid Reference.\n");
|
return -EINVAL;
|
}
|
|
*out_store = static_cast<uint64_t>(buffer->get_id());
|
return 0;
|
}
|
|
cros_gralloc_buffer *cros_gralloc_driver::get_buffer(cros_gralloc_handle_t hnd)
|
{
|
/* Assumes driver mutex is held. */
|
if (handles_.count(hnd))
|
return handles_[hnd].first;
|
|
return nullptr;
|
}
|
