uint64_t use_flags)
{
int ret;
+ size_t num_planes;
uint32_t plane, stride;
- union drm_amdgpu_gem_create gem_create;
+ union drm_amdgpu_gem_create gem_create = { { 0 } };
struct amdgpu_priv *priv = bo->drv->priv;
stride = drv_stride_from_format(format, width, 0);
- stride = ALIGN(stride, 256);
+ num_planes = drv_num_planes_from_format(format);
+
+ /*
+ * For multiplane formats, align the stride to 512 to ensure that subsample strides are 256
+ * aligned. This uses more memory than necessary since the first plane only needs to be
+ * 256 aligned, but it's acceptable for a short-term fix. It's probably safe for other gpu
+ * families, but let's restrict it to Raven for now (b/171013552).
+ * */
+ if (priv->dev_info.family == AMDGPU_FAMILY_RV && num_planes > 1)
+ stride = ALIGN(stride, 512);
+ else
+ stride = ALIGN(stride, 256);
/*
* Currently, allocator used by chrome aligns the height for Encoder/
drv_bo_from_format(bo, stride, height, format);
- memset(&gem_create, 0, sizeof(gem_create));
gem_create.in.bo_size =
ALIGN(bo->meta.total_size, priv->dev_info.virtual_address_alignment);
gem_create.in.alignment = 256;
{
void *addr = MAP_FAILED;
int ret;
- union drm_amdgpu_gem_mmap gem_map;
+ union drm_amdgpu_gem_mmap gem_map = { { 0 } };
struct drm_amdgpu_gem_create_in bo_info = { 0 };
struct drm_amdgpu_gem_op gem_op = { 0 };
uint32_t handle = bo->handles[plane].u32;
}
}
- memset(&gem_map, 0, sizeof(gem_map));
gem_map.in.handle = handle;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_AMDGPU_GEM_MMAP, &gem_map);
if (ret) {
drv_log("DRM_IOCTL_AMDGPU_GEM_MMAP failed\n");
static int amdgpu_bo_invalidate(struct bo *bo, struct mapping *mapping)
{
int ret;
- union drm_amdgpu_gem_wait_idle wait_idle;
+ union drm_amdgpu_gem_wait_idle wait_idle = { { 0 } };
if (bo->priv)
return 0;
- memset(&wait_idle, 0, sizeof(wait_idle));
wait_idle.in.handle = bo->handles[0].u32;
wait_idle.in.timeout = AMDGPU_TIMEOUT_INFINITE;
return 0;
}
+
+std::string get_drm_format_string(uint32_t drm_format)
+{
+ char *sequence = (char *)&drm_format;
+ std::string s(sequence, 4);
+ return "DRM_FOURCC_" + s;
+}
int32_t cros_gralloc_sync_wait(int32_t fence, bool close_fence);
+std::string get_drm_format_string(uint32_t drm_format);
+
#endif
* rockchip) and usb monitors (evdi/udl). It's complicated so ignore it.
* */
use_flags |= BO_USE_NONE;
+ /* Map this flag to linear until real HW protection is available on Android. */
if (usage & GRALLOC_USAGE_PROTECTED)
- use_flags |= BO_USE_PROTECTED;
+ use_flags |= BO_USE_LINEAR;
if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
use_flags |= BO_USE_HW_VIDEO_ENCODER;
/*HACK: See b/30054495 */
CHECK(allocate(ctx->device, &info));
CHECK(mod->perform(mod, GRALLOC_DRM_GET_STRIDE, info.handle, &stride) == 0);
- CHECK(stride == info.stride);
+ CHECK(stride >= info.stride);
CHECK(mod->perform(mod, GRALLOC_DRM_GET_FORMAT, info.handle, &format) == 0);
CHECK(format == info.format);
if (strcmp(tests[i].name, name) && strcmp("all", name))
continue;
+ printf("[ RUN ] gralloctest.%s\n", tests[i].name);
+
int success = 1;
if (ctx->api >= tests[i].required_api)
success = tests[i].run_test(ctx);
- printf("[ RUN ] gralloctest.%s\n", tests[i].name);
if (!success) {
fprintf(stderr, "[ FAILED ] gralloctest.%s\n", tests[i].name);
ret |= 1;
}
if (!supported) {
- std::string drmFormatString = getDrmFormatString(crosDescriptor.drm_format);
+ std::string drmFormatString = get_drm_format_string(crosDescriptor.drm_format);
std::string pixelFormatString = getPixelFormatString(descriptor.format);
std::string usageString = getUsageString(descriptor.usage);
drv_log("Unsupported combination -- pixel format: %s, drm format:%s, usage: %s\n",
#include <cutils/native_handle.h>
+#include "cros_gralloc/cros_gralloc_helpers.h"
#include "cros_gralloc/gralloc3/CrosGralloc3Utils.h"
+
#include "helpers.h"
using android::hardware::hidl_handle;
break;
}
default: {
- std::string format = getDrmFormatString(crosHandle->format);
+ std::string format = get_drm_format_string(crosHandle->format);
drv_log("Failed to lockYCbCr. Unhandled format: %s\n", format.c_str());
hidlCb(Error::BAD_BUFFER, ycbcr);
return Void();
uint32_t resolvedDrmFormat = mDriver->get_resolved_drm_format(drmFormat, usage);
if (resolvedDrmFormat == DRM_FORMAT_INVALID) {
- std::string drmFormatString = getDrmFormatString(drmFormat);
+ std::string drmFormatString = get_drm_format_string(drmFormat);
drv_log("Failed to getResolvedDrmFormat. Failed to resolve drm format %s\n",
drmFormatString.c_str());
return -1;
using BufferDescriptorInfo =
android::hardware::graphics::mapper::V3_0::IMapper::BufferDescriptorInfo;
-std::string getDrmFormatString(uint32_t drmFormat) {
- switch (drmFormat) {
- case DRM_FORMAT_ABGR1555:
- return "DRM_FORMAT_ABGR1555";
- case DRM_FORMAT_ABGR2101010:
- return "DRM_FORMAT_ABGR2101010";
- case DRM_FORMAT_ABGR4444:
- return "DRM_FORMAT_ABGR4444";
- case DRM_FORMAT_ABGR8888:
- return "DRM_FORMAT_ABGR8888";
- case DRM_FORMAT_ARGB1555:
- return "DRM_FORMAT_ARGB1555";
- case DRM_FORMAT_ARGB2101010:
- return "DRM_FORMAT_ARGB2101010";
- case DRM_FORMAT_ARGB4444:
- return "DRM_FORMAT_ARGB4444";
- case DRM_FORMAT_ARGB8888:
- return "DRM_FORMAT_ARGB8888";
- case DRM_FORMAT_AYUV:
- return "DRM_FORMAT_AYUV";
- case DRM_FORMAT_BGR233:
- return "DRM_FORMAT_BGR233";
- case DRM_FORMAT_BGR565:
- return "DRM_FORMAT_BGR565";
- case DRM_FORMAT_BGR888:
- return "DRM_FORMAT_BGR888";
- case DRM_FORMAT_BGRA1010102:
- return "DRM_FORMAT_BGRA1010102";
- case DRM_FORMAT_BGRA4444:
- return "DRM_FORMAT_BGRA4444";
- case DRM_FORMAT_BGRA5551:
- return "DRM_FORMAT_BGRA5551";
- case DRM_FORMAT_BGRA8888:
- return "DRM_FORMAT_BGRA8888";
- case DRM_FORMAT_BGRX1010102:
- return "DRM_FORMAT_BGRX1010102";
- case DRM_FORMAT_BGRX4444:
- return "DRM_FORMAT_BGRX4444";
- case DRM_FORMAT_BGRX5551:
- return "DRM_FORMAT_BGRX5551";
- case DRM_FORMAT_BGRX8888:
- return "DRM_FORMAT_BGRX8888";
- case DRM_FORMAT_C8:
- return "DRM_FORMAT_C8";
- case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
- return "DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED";
- case DRM_FORMAT_GR88:
- return "DRM_FORMAT_GR88";
- case DRM_FORMAT_NV12:
- return "DRM_FORMAT_NV12";
- case DRM_FORMAT_NV21:
- return "DRM_FORMAT_NV21";
- case DRM_FORMAT_R8:
- return "DRM_FORMAT_R8";
- case DRM_FORMAT_RG88:
- return "DRM_FORMAT_RG88";
- case DRM_FORMAT_RGB332:
- return "DRM_FORMAT_RGB332";
- case DRM_FORMAT_RGB565:
- return "DRM_FORMAT_RGB565";
- case DRM_FORMAT_RGB888:
- return "DRM_FORMAT_RGB888";
- case DRM_FORMAT_RGBA1010102:
- return "DRM_FORMAT_RGBA1010102";
- case DRM_FORMAT_RGBA4444:
- return "DRM_FORMAT_RGBA4444";
- case DRM_FORMAT_RGBA5551:
- return "DRM_FORMAT_RGBA5551";
- case DRM_FORMAT_RGBA8888:
- return "DRM_FORMAT_RGBA8888";
- case DRM_FORMAT_RGBX1010102:
- return "DRM_FORMAT_RGBX1010102";
- case DRM_FORMAT_RGBX4444:
- return "DRM_FORMAT_RGBX4444";
- case DRM_FORMAT_RGBX5551:
- return "DRM_FORMAT_RGBX5551";
- case DRM_FORMAT_RGBX8888:
- return "DRM_FORMAT_RGBX8888";
- case DRM_FORMAT_UYVY:
- return "DRM_FORMAT_UYVY";
- case DRM_FORMAT_VYUY:
- return "DRM_FORMAT_VYUY";
- case DRM_FORMAT_XBGR1555:
- return "DRM_FORMAT_XBGR1555";
- case DRM_FORMAT_XBGR2101010:
- return "DRM_FORMAT_XBGR2101010";
- case DRM_FORMAT_XBGR4444:
- return "DRM_FORMAT_XBGR4444";
- case DRM_FORMAT_XBGR8888:
- return "DRM_FORMAT_XBGR8888";
- case DRM_FORMAT_XRGB1555:
- return "DRM_FORMAT_XRGB1555";
- case DRM_FORMAT_XRGB2101010:
- return "DRM_FORMAT_XRGB2101010";
- case DRM_FORMAT_XRGB4444:
- return "DRM_FORMAT_XRGB4444";
- case DRM_FORMAT_XRGB8888:
- return "DRM_FORMAT_XRGB8888";
- case DRM_FORMAT_YUYV:
- return "DRM_FORMAT_YUYV";
- case DRM_FORMAT_YVU420:
- return "DRM_FORMAT_YVU420";
- case DRM_FORMAT_YVU420_ANDROID:
- return "DRM_FORMAT_YVU420";
- case DRM_FORMAT_YVYU:
- return "DRM_FORMAT_YVYU";
- }
- return android::base::StringPrintf("Unknown(%d)", drmFormat);
-}
-
std::string getPixelFormatString(PixelFormat format) {
switch (format) {
case PixelFormat::BGRA_8888:
/* HWC wants to use display hardware, but can defer to OpenGL. */
bufferUsage |= BO_USE_SCANOUT | BO_USE_TEXTURE;
}
+ /* Map this flag to linear until real HW protection is available on Android. */
if (grallocUsage & BufferUsage::PROTECTED) {
- bufferUsage |= BO_USE_PROTECTED;
+ bufferUsage |= BO_USE_LINEAR;
}
if (grallocUsage & BufferUsage::COMPOSER_CURSOR) {
bufferUsage |= BO_USE_NONE;
encoded[3] = static_cast<uint32_t>(info.format);
encoded[4] = info.usage & std::numeric_limits<uint32_t>::max();
return std::move(encoded);
-}
\ No newline at end of file
+}
#include <android/hardware/graphics/common/1.2/types.h>
#include <android/hardware/graphics/mapper/3.0/IMapper.h>
-std::string getDrmFormatString(uint32_t drmFormat);
-
std::string getPixelFormatString(android::hardware::graphics::common::V1_2::PixelFormat format);
std::string getUsageString(
}
if (!supported) {
- std::string drmFormatString = getDrmFormatString(crosDescriptor.drm_format);
+ std::string drmFormatString = get_drm_format_string(crosDescriptor.drm_format);
std::string pixelFormatString = getPixelFormatString(descriptor.format);
std::string usageString = getUsageString(descriptor.usage);
drv_log("Unsupported combination -- pixel format: %s, drm format:%s, usage: %s\n",
#include <cutils/native_handle.h>
#include <gralloctypes/Gralloc4.h>
+#include "cros_gralloc/cros_gralloc_helpers.h"
#include "cros_gralloc/gralloc4/CrosGralloc4Utils.h"
+
#include "helpers.h"
using aidl::android::hardware::graphics::common::BlendMode;
planeLayout.offsetInBytes = crosHandle->offsets[plane];
planeLayout.strideInBytes = crosHandle->strides[plane];
planeLayout.totalSizeInBytes = crosHandle->sizes[plane];
- planeLayout.widthInSamples = crosHandle->width;
- planeLayout.heightInSamples = crosHandle->height;
+ planeLayout.widthInSamples = crosHandle->width / planeLayout.horizontalSubsampling;
+ planeLayout.heightInSamples = crosHandle->height / planeLayout.verticalSubsampling;
}
status = android::gralloc4::encodePlaneLayouts(planeLayouts, &encodedMetadata);
uint32_t resolvedDrmFormat = mDriver->get_resolved_drm_format(drmFormat, usage);
if (resolvedDrmFormat == DRM_FORMAT_INVALID) {
- std::string drmFormatString = getDrmFormatString(drmFormat);
+ std::string drmFormatString = get_drm_format_string(drmFormat);
drv_log("Failed to getResolvedDrmFormat. Failed to resolve drm format %s\n",
drmFormatString.c_str());
return -1;
using BufferDescriptorInfo =
android::hardware::graphics::mapper::V4_0::IMapper::BufferDescriptorInfo;
-std::string getDrmFormatString(uint32_t drmFormat) {
- switch (drmFormat) {
- case DRM_FORMAT_ABGR1555:
- return "DRM_FORMAT_ABGR1555";
- case DRM_FORMAT_ABGR2101010:
- return "DRM_FORMAT_ABGR2101010";
- case DRM_FORMAT_ABGR4444:
- return "DRM_FORMAT_ABGR4444";
- case DRM_FORMAT_ABGR8888:
- return "DRM_FORMAT_ABGR8888";
- case DRM_FORMAT_ARGB1555:
- return "DRM_FORMAT_ARGB1555";
- case DRM_FORMAT_ARGB2101010:
- return "DRM_FORMAT_ARGB2101010";
- case DRM_FORMAT_ARGB4444:
- return "DRM_FORMAT_ARGB4444";
- case DRM_FORMAT_ARGB8888:
- return "DRM_FORMAT_ARGB8888";
- case DRM_FORMAT_AYUV:
- return "DRM_FORMAT_AYUV";
- case DRM_FORMAT_BGR233:
- return "DRM_FORMAT_BGR233";
- case DRM_FORMAT_BGR565:
- return "DRM_FORMAT_BGR565";
- case DRM_FORMAT_BGR888:
- return "DRM_FORMAT_BGR888";
- case DRM_FORMAT_BGRA1010102:
- return "DRM_FORMAT_BGRA1010102";
- case DRM_FORMAT_BGRA4444:
- return "DRM_FORMAT_BGRA4444";
- case DRM_FORMAT_BGRA5551:
- return "DRM_FORMAT_BGRA5551";
- case DRM_FORMAT_BGRA8888:
- return "DRM_FORMAT_BGRA8888";
- case DRM_FORMAT_BGRX1010102:
- return "DRM_FORMAT_BGRX1010102";
- case DRM_FORMAT_BGRX4444:
- return "DRM_FORMAT_BGRX4444";
- case DRM_FORMAT_BGRX5551:
- return "DRM_FORMAT_BGRX5551";
- case DRM_FORMAT_BGRX8888:
- return "DRM_FORMAT_BGRX8888";
- case DRM_FORMAT_C8:
- return "DRM_FORMAT_C8";
- case DRM_FORMAT_GR88:
- return "DRM_FORMAT_GR88";
- case DRM_FORMAT_NV12:
- return "DRM_FORMAT_NV12";
- case DRM_FORMAT_NV21:
- return "DRM_FORMAT_NV21";
- case DRM_FORMAT_R8:
- return "DRM_FORMAT_R8";
- case DRM_FORMAT_RG88:
- return "DRM_FORMAT_RG88";
- case DRM_FORMAT_RGB332:
- return "DRM_FORMAT_RGB332";
- case DRM_FORMAT_RGB565:
- return "DRM_FORMAT_RGB565";
- case DRM_FORMAT_RGB888:
- return "DRM_FORMAT_RGB888";
- case DRM_FORMAT_RGBA1010102:
- return "DRM_FORMAT_RGBA1010102";
- case DRM_FORMAT_RGBA4444:
- return "DRM_FORMAT_RGBA4444";
- case DRM_FORMAT_RGBA5551:
- return "DRM_FORMAT_RGBA5551";
- case DRM_FORMAT_RGBA8888:
- return "DRM_FORMAT_RGBA8888";
- case DRM_FORMAT_RGBX1010102:
- return "DRM_FORMAT_RGBX1010102";
- case DRM_FORMAT_RGBX4444:
- return "DRM_FORMAT_RGBX4444";
- case DRM_FORMAT_RGBX5551:
- return "DRM_FORMAT_RGBX5551";
- case DRM_FORMAT_RGBX8888:
- return "DRM_FORMAT_RGBX8888";
- case DRM_FORMAT_UYVY:
- return "DRM_FORMAT_UYVY";
- case DRM_FORMAT_VYUY:
- return "DRM_FORMAT_VYUY";
- case DRM_FORMAT_XBGR1555:
- return "DRM_FORMAT_XBGR1555";
- case DRM_FORMAT_XBGR2101010:
- return "DRM_FORMAT_XBGR2101010";
- case DRM_FORMAT_XBGR4444:
- return "DRM_FORMAT_XBGR4444";
- case DRM_FORMAT_XBGR8888:
- return "DRM_FORMAT_XBGR8888";
- case DRM_FORMAT_XRGB1555:
- return "DRM_FORMAT_XRGB1555";
- case DRM_FORMAT_XRGB2101010:
- return "DRM_FORMAT_XRGB2101010";
- case DRM_FORMAT_XRGB4444:
- return "DRM_FORMAT_XRGB4444";
- case DRM_FORMAT_XRGB8888:
- return "DRM_FORMAT_XRGB8888";
- case DRM_FORMAT_YUYV:
- return "DRM_FORMAT_YUYV";
- case DRM_FORMAT_YVU420:
- return "DRM_FORMAT_YVU420";
- case DRM_FORMAT_YVYU:
- return "DRM_FORMAT_YVYU";
- }
- return android::base::StringPrintf("Unknown(%d)", drmFormat);
-}
-
std::string getPixelFormatString(PixelFormat format) {
switch (format) {
case PixelFormat::BGRA_8888:
/* HWC wants to use display hardware, but can defer to OpenGL. */
bufferUsage |= BO_USE_SCANOUT | BO_USE_TEXTURE;
}
+ /* Map this flag to linear until real HW protection is available on Android. */
if (grallocUsage & BufferUsage::PROTECTED) {
- bufferUsage |= BO_USE_PROTECTED;
+ bufferUsage |= BO_USE_LINEAR;
}
if (grallocUsage & BufferUsage::COMPOSER_CURSOR) {
bufferUsage |= BO_USE_NONE;
*outPlaneLayouts = it->second;
return 0;
-}
\ No newline at end of file
+}
#include "cros_gralloc/cros_gralloc_types.h"
-std::string getDrmFormatString(uint32_t drmFormat);
-
std::string getPixelFormatString(android::hardware::graphics::common::V1_2::PixelFormat format);
std::string getUsageString(
int getPlaneLayouts(
uint32_t drm_format,
- std::vector<aidl::android::hardware::graphics::common::PlaneLayout>* out_layouts);
\ No newline at end of file
+ std::vector<aidl::android::hardware::graphics::common::PlaneLayout>* out_layouts);
*/
static void close_gem_handle(uint32_t handle, int fd)
{
- struct drm_gem_close gem_close;
+ struct drm_gem_close gem_close = { 0 };
int ret = 0;
- memset(&gem_close, 0, sizeof(gem_close));
gem_close.handle = handle;
ret = drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
if (ret)
#ifdef DRV_AMDGPU
extern const struct backend backend_amdgpu;
#endif
-extern const struct backend backend_evdi;
#ifdef DRV_EXYNOS
extern const struct backend backend_exynos;
#endif
#ifdef DRV_I915
extern const struct backend backend_i915;
#endif
-#ifdef DRV_MARVELL
-extern const struct backend backend_marvell;
-#endif
#ifdef DRV_MEDIATEK
extern const struct backend backend_mediatek;
#endif
-#ifdef DRV_MESON
-extern const struct backend backend_meson;
-#endif
#ifdef DRV_MSM
extern const struct backend backend_msm;
#endif
-extern const struct backend backend_nouveau;
-#ifdef DRV_RADEON
-extern const struct backend backend_radeon;
-#endif
#ifdef DRV_ROCKCHIP
extern const struct backend backend_rockchip;
#endif
-#ifdef DRV_SYNAPTICS
-extern const struct backend backend_synaptics;
-#endif
#ifdef DRV_TEGRA
extern const struct backend backend_tegra;
#endif
-extern const struct backend backend_udl;
#ifdef DRV_VC4
extern const struct backend backend_vc4;
#endif
-extern const struct backend backend_vgem;
+
+// Dumb / generic drivers
+extern const struct backend backend_evdi;
+extern const struct backend backend_marvell;
+extern const struct backend backend_meson;
+extern const struct backend backend_nouveau;
+extern const struct backend backend_komeda;
+extern const struct backend backend_radeon;
+extern const struct backend backend_synaptics;
extern const struct backend backend_virtio_gpu;
+extern const struct backend backend_udl;
static const struct backend *drv_get_backend(int fd)
{
#ifdef DRV_AMDGPU
&backend_amdgpu,
#endif
- &backend_evdi,
#ifdef DRV_EXYNOS
&backend_exynos,
#endif
#ifdef DRV_I915
&backend_i915,
#endif
-#ifdef DRV_MARVELL
- &backend_marvell,
-#endif
#ifdef DRV_MEDIATEK
&backend_mediatek,
#endif
-#ifdef DRV_MESON
- &backend_meson,
-#endif
#ifdef DRV_MSM
&backend_msm,
#endif
- &backend_nouveau,
-#ifdef DRV_RADEON
- &backend_radeon,
-#endif
#ifdef DRV_ROCKCHIP
&backend_rockchip,
#endif
-#ifdef DRV_SYNAPTICS
- &backend_synaptics,
-#endif
-#ifdef DRV_TEGRA
- &backend_tegra,
-#endif
- &backend_udl,
#ifdef DRV_VC4
&backend_vc4,
#endif
- &backend_vgem, &backend_virtio_gpu,
+ &backend_marvell, &backend_meson, &backend_nouveau, &backend_komeda,
+ &backend_radeon, &backend_synaptics, &backend_virtio_gpu,
};
for (i = 0; i < ARRAY_SIZE(backend_list); i++) {
{
uint32_t i;
uint8_t *addr;
- struct mapping mapping;
+ struct mapping mapping = { 0 };
assert(rect->width >= 0);
assert(rect->height >= 0);
return MAP_FAILED;
}
- memset(&mapping, 0, sizeof(mapping));
mapping.rect = *rect;
mapping.refcount = 1;
};
// clang-format off
-#define BO_USE_RENDER_MASK (BO_USE_LINEAR | BO_USE_PROTECTED | BO_USE_RENDERING | \
- BO_USE_RENDERSCRIPT | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN | \
- BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY | BO_USE_TEXTURE)
+#define BO_USE_RENDER_MASK (BO_USE_LINEAR | BO_USE_RENDERING | BO_USE_RENDERSCRIPT | \
+ BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN | BO_USE_SW_READ_RARELY | \
+ BO_USE_SW_WRITE_RARELY | BO_USE_TEXTURE)
-#define BO_USE_TEXTURE_MASK (BO_USE_LINEAR | BO_USE_PROTECTED | BO_USE_RENDERSCRIPT | \
- BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN | \
- BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY | BO_USE_TEXTURE)
+#define BO_USE_TEXTURE_MASK (BO_USE_LINEAR | BO_USE_RENDERSCRIPT | BO_USE_SW_READ_OFTEN | \
+ BO_USE_SW_WRITE_OFTEN | BO_USE_SW_READ_RARELY | \
+ BO_USE_SW_WRITE_RARELY | BO_USE_TEXTURE)
#define BO_USE_SW_MASK (BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN | \
- BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY)
+ BO_USE_SW_READ_RARELY | BO_USE_SW_WRITE_RARELY)
#define BO_USE_NON_GPU_HW (BO_USE_SCANOUT | BO_USE_CAMERA_WRITE | BO_USE_CAMERA_READ | \
- BO_USE_HW_VIDEO_ENCODER | BO_USE_HW_VIDEO_DECODER)
+ BO_USE_HW_VIDEO_ENCODER | BO_USE_HW_VIDEO_DECODER)
#ifndef DRM_FORMAT_MOD_LINEAR
#define DRM_FORMAT_MOD_LINEAR DRM_FORMAT_MOD_NONE
/*
- * Copyright 2018 The Chromium OS Authors. All rights reserved.
+ * Copyright 2020 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.
*/
-#ifdef DRV_MESON
-
#include "drv_priv.h"
#include "helpers.h"
#include "util.h"
+#define INIT_DUMB_DRIVER(driver) \
+ const struct backend backend_##driver = { \
+ .name = #driver, \
+ .init = dumb_driver_init, \
+ .bo_create = drv_dumb_bo_create, \
+ .bo_destroy = drv_dumb_bo_destroy, \
+ .bo_import = drv_prime_bo_import, \
+ .bo_map = drv_dumb_bo_map, \
+ .bo_unmap = drv_bo_munmap, \
+ };
+
static const uint32_t scanout_render_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888,
DRM_FORMAT_ABGR8888, DRM_FORMAT_XBGR8888,
DRM_FORMAT_BGR888, DRM_FORMAT_BGR565 };
static const uint32_t texture_only_formats[] = { DRM_FORMAT_NV12, DRM_FORMAT_NV21,
DRM_FORMAT_YVU420, DRM_FORMAT_YVU420_ANDROID };
-static int meson_init(struct driver *drv)
+static int dumb_driver_init(struct driver *drv)
{
drv_add_combinations(drv, scanout_render_formats, ARRAY_SIZE(scanout_render_formats),
&LINEAR_METADATA, BO_USE_RENDER_MASK | BO_USE_SCANOUT);
return drv_modify_linear_combinations(drv);
}
-const struct backend backend_meson = {
- .name = "meson",
- .init = meson_init,
- .bo_create = drv_dumb_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
-};
-
-#endif
+INIT_DUMB_DRIVER(komeda)
+INIT_DUMB_DRIVER(marvell)
+INIT_DUMB_DRIVER(meson)
+INIT_DUMB_DRIVER(nouveau)
+INIT_DUMB_DRIVER(radeon)
+INIT_DUMB_DRIVER(synaptics)
+++ /dev/null
-/*
- * Copyright 2016 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 "drv_priv.h"
-#include "helpers.h"
-#include "util.h"
-
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888 };
-
-static int evdi_init(struct driver *drv)
-{
- drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
- &LINEAR_METADATA, BO_USE_RENDER_MASK);
-
- return drv_modify_linear_combinations(drv);
-}
-
-const struct backend backend_evdi = {
- .name = "evdi",
- .init = evdi_init,
- .bo_create = drv_dumb_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
-};
int ret;
for (plane = 0; plane < bo->meta.num_planes; plane++) {
size_t size = bo->meta.sizes[plane];
- struct drm_exynos_gem_create gem_create;
+ struct drm_exynos_gem_create gem_create = { 0 };
- memset(&gem_create, 0, sizeof(gem_create));
gem_create.size = size;
gem_create.flags = EXYNOS_BO_NONCONTIG;
cleanup_planes:
for (; plane != 0; plane--) {
- struct drm_gem_close gem_close;
- memset(&gem_close, 0, sizeof(gem_close));
+ struct drm_gem_close gem_close = { 0 };
+
gem_close.handle = bo->handles[plane - 1].u32;
int gem_close_ret = drmIoctl(bo->drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
if (gem_close_ret) {
uint32_t usage)
{
struct gbm_bo *bo;
- struct drv_import_fd_data drv_data;
+ struct drv_import_fd_data drv_data = { 0 };
struct gbm_import_fd_data *fd_data = buffer;
struct gbm_import_fd_modifier_data *fd_modifier_data = buffer;
uint32_t gbm_format;
size_t num_planes, i, num_fds;
- memset(&drv_data, 0, sizeof(drv_data));
drv_data.use_flags = gbm_convert_usage(usage);
switch (type) {
case GBM_BO_IMPORT_FD:
int ret;
size_t plane;
uint32_t aligned_width, aligned_height;
- struct drm_mode_create_dumb create_dumb;
+ struct drm_mode_create_dumb create_dumb = { 0 };
aligned_width = width;
aligned_height = height;
break;
}
- memset(&create_dumb, 0, sizeof(create_dumb));
if (quirks & BO_QUIRK_DUMB32BPP) {
aligned_width =
DIV_ROUND_UP(aligned_width * layout_from_format(format)->bytes_per_pixel[0], 4);
int drv_dumb_bo_destroy(struct bo *bo)
{
- struct drm_mode_destroy_dumb destroy_dumb;
int ret;
+ struct drm_mode_destroy_dumb destroy_dumb = { 0 };
- memset(&destroy_dumb, 0, sizeof(destroy_dumb));
destroy_dumb.handle = bo->handles[0].u32;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
if (ret) {
drv_log("DRM_IOCTL_MODE_DESTROY_DUMB failed (handle=%x)\n", bo->handles[0].u32);
const uint16_t gen3_ids[] = { 0x2582, 0x2592, 0x2772, 0x27A2, 0x27AE,
0x29C2, 0x29B2, 0x29D2, 0xA001, 0xA011 };
const uint16_t gen11_ids[] = { 0x4E71, 0x4E61, 0x4E51, 0x4E55, 0x4E57 };
-
+ const uint16_t gen12_ids[] = { 0x9A40, 0x9A49, 0x9A59, 0x9A60, 0x9A68,
+ 0x9A70, 0x9A78, 0x9AC0, 0x9AC9, 0x9AD9,
+ 0x9AF8 };
unsigned i;
for (i = 0; i < ARRAY_SIZE(gen3_ids); i++)
if (gen3_ids[i] == device_id)
if (gen11_ids[i] == device_id)
return 11;
+ /* Gen 12 */
+ for (i = 0; i < ARRAY_SIZE(gen12_ids); i++)
+ if (gen12_ids[i] == device_id)
+ return 12;
+
return 4;
}
scanout_and_render = BO_USE_RENDER_MASK | BO_USE_SCANOUT;
render = BO_USE_RENDER_MASK;
texture_only = BO_USE_TEXTURE_MASK;
- uint64_t linear_mask = BO_USE_RENDERSCRIPT | BO_USE_LINEAR | BO_USE_PROTECTED |
- BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN;
+ uint64_t linear_mask =
+ BO_USE_RENDERSCRIPT | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN;
metadata.tiling = I915_TILING_NONE;
metadata.priority = 1;
int ret;
int device_id;
struct i915_device *i915;
- drm_i915_getparam_t get_param;
+ drm_i915_getparam_t get_param = { 0 };
i915 = calloc(1, sizeof(*i915));
if (!i915)
return -ENOMEM;
- memset(&get_param, 0, sizeof(get_param));
get_param.param = I915_PARAM_CHIPSET_ID;
get_param.value = &device_id;
ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GETPARAM, &get_param);
{
uint64_t modifier;
struct i915_device *i915 = bo->drv->priv;
- bool huge_bo = (i915->gen <= 11) && (width > 4096);
+ bool huge_bo = (i915->gen < 11) && (width > 4096);
if (modifiers) {
modifier =
{
int ret;
size_t plane;
- struct drm_i915_gem_create gem_create;
- struct drm_i915_gem_set_tiling gem_set_tiling;
+ struct drm_i915_gem_create gem_create = { 0 };
+ struct drm_i915_gem_set_tiling gem_set_tiling = { 0 };
- memset(&gem_create, 0, sizeof(gem_create));
gem_create.size = bo->meta.total_size;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_CREATE, &gem_create);
if (ret) {
drv_log("DRM_IOCTL_I915_GEM_CREATE failed (size=%llu)\n", gem_create.size);
for (plane = 0; plane < bo->meta.num_planes; plane++)
bo->handles[plane].u32 = gem_create.handle;
- memset(&gem_set_tiling, 0, sizeof(gem_set_tiling));
gem_set_tiling.handle = bo->handles[0].u32;
gem_set_tiling.tiling_mode = bo->meta.tiling;
gem_set_tiling.stride = bo->meta.strides[0];
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_SET_TILING, &gem_set_tiling);
if (ret) {
- struct drm_gem_close gem_close;
- memset(&gem_close, 0, sizeof(gem_close));
+ struct drm_gem_close gem_close = { 0 };
gem_close.handle = bo->handles[0].u32;
drmIoctl(bo->drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
static int i915_bo_import(struct bo *bo, struct drv_import_fd_data *data)
{
int ret;
- struct drm_i915_gem_get_tiling gem_get_tiling;
+ struct drm_i915_gem_get_tiling gem_get_tiling = { 0 };
ret = drv_prime_bo_import(bo, data);
if (ret)
return ret;
/* TODO(gsingh): export modifiers and get rid of backdoor tiling. */
- memset(&gem_get_tiling, 0, sizeof(gem_get_tiling));
gem_get_tiling.handle = bo->handles[0].u32;
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_GET_TILING, &gem_get_tiling);
return MAP_FAILED;
if (bo->meta.tiling == I915_TILING_NONE) {
- struct drm_i915_gem_mmap gem_map;
- memset(&gem_map, 0, sizeof(gem_map));
-
+ struct drm_i915_gem_mmap gem_map = { 0 };
/* TODO(b/118799155): We don't seem to have a good way to
* detect the use cases for which WC mapping is really needed.
* The current heuristic seems overly coarse and may be slowing
addr = (void *)(uintptr_t)gem_map.addr_ptr;
} else {
- struct drm_i915_gem_mmap_gtt gem_map;
- memset(&gem_map, 0, sizeof(gem_map));
+ struct drm_i915_gem_mmap_gtt gem_map = { 0 };
gem_map.handle = bo->handles[0].u32;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_I915_GEM_MMAP_GTT, &gem_map);
if (ret) {
drv_log("DRM_IOCTL_I915_GEM_MMAP_GTT failed\n");
static int i915_bo_invalidate(struct bo *bo, struct mapping *mapping)
{
int ret;
- struct drm_i915_gem_set_domain set_domain;
+ struct drm_i915_gem_set_domain set_domain = { 0 };
- memset(&set_domain, 0, sizeof(set_domain));
set_domain.handle = bo->handles[0].u32;
if (bo->meta.tiling == I915_TILING_NONE) {
set_domain.read_domains = I915_GEM_DOMAIN_CPU;
+++ /dev/null
-/*
- * Copyright 2015 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.
- */
-
-#ifdef DRV_MARVELL
-
-#include "drv_priv.h"
-#include "helpers.h"
-#include "util.h"
-
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888 };
-
-static int marvell_init(struct driver *drv)
-{
- drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
- &LINEAR_METADATA, BO_USE_RENDER_MASK);
-
- return drv_add_linear_combinations(drv, render_target_formats,
- ARRAY_SIZE(render_target_formats));
-}
-
-const struct backend backend_marvell = {
- .name = "marvell",
- .init = marvell_init,
- .bo_create = drv_dumb_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
-};
-
-#endif
drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
&LINEAR_METADATA, BO_USE_TEXTURE_MASK);
- drv_add_combination(drv, DRM_FORMAT_R8, &LINEAR_METADATA,
- BO_USE_SW_MASK | BO_USE_LINEAR | BO_USE_PROTECTED);
+ drv_add_combination(drv, DRM_FORMAT_R8, &LINEAR_METADATA, BO_USE_SW_MASK | BO_USE_LINEAR);
/* Android CTS tests require this. */
drv_add_combination(drv, DRM_FORMAT_BGR888, &LINEAR_METADATA, BO_USE_SW_MASK);
int ret;
size_t plane;
uint32_t stride;
- struct drm_mtk_gem_create gem_create;
+ struct drm_mtk_gem_create gem_create = { 0 };
if (!drv_has_modifier(modifiers, count, DRM_FORMAT_MOD_LINEAR)) {
errno = EINVAL;
drv_bo_from_format(bo, stride, height, format);
}
- memset(&gem_create, 0, sizeof(gem_create));
gem_create.size = bo->meta.total_size;
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MTK_GEM_CREATE, &gem_create);
static void *mediatek_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
{
int ret, prime_fd;
- struct drm_mtk_gem_map_off gem_map;
+ struct drm_mtk_gem_map_off gem_map = { 0 };
struct mediatek_private_map_data *priv;
- memset(&gem_map, 0, sizeof(gem_map));
gem_map.handle = bo->handles[0].u32;
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MTK_GEM_MAP_OFFSET, &gem_map);
uv_stride = ALIGN(width, VENUS_STRIDE_ALIGN);
y_scanline = ALIGN(height, VENUS_SCANLINE_ALIGN * 2);
uv_scanline = ALIGN(DIV_ROUND_UP(height, 2),
- VENUS_SCANLINE_ALIGN * (bo->meta.tiling ? 2 : 1));
+ VENUS_SCANLINE_ALIGN * (bo->meta.tiling ? 2 : 1));
y_plane = y_stride * y_scanline;
uv_plane = uv_stride * uv_scanline;
struct format_metadata metadata;
uint64_t render_use_flags = BO_USE_RENDER_MASK | BO_USE_SCANOUT;
uint64_t texture_use_flags = BO_USE_TEXTURE_MASK | BO_USE_HW_VIDEO_DECODER;
- uint64_t sw_flags = (BO_USE_RENDERSCRIPT | BO_USE_SW_MASK |
- BO_USE_LINEAR | BO_USE_PROTECTED);
+ uint64_t sw_flags = (BO_USE_RENDERSCRIPT | BO_USE_SW_MASK | BO_USE_LINEAR);
drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
&LINEAR_METADATA, render_use_flags);
msm_add_ubwc_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
&metadata, texture_use_flags);
+ drv_modify_combination(drv, DRM_FORMAT_NV12, &metadata,
+ BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE | BO_USE_SCANOUT |
+ BO_USE_HW_VIDEO_ENCODER);
+
return 0;
}
static int msm_bo_create_for_modifier(struct bo *bo, uint32_t width, uint32_t height,
uint32_t format, const uint64_t modifier)
{
- struct drm_msm_gem_new req;
+ struct drm_msm_gem_new req = { 0 };
int ret;
size_t i;
bo->meta.tiling = (modifier == DRM_FORMAT_MOD_QCOM_COMPRESSED) ? MSM_UBWC_TILING : 0;
-
msm_calculate_layout(bo);
- memset(&req, 0, sizeof(req));
req.flags = MSM_BO_WC | MSM_BO_SCANOUT;
req.size = bo->meta.total_size;
static void *msm_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
{
int ret;
- struct drm_msm_gem_info req;
+ struct drm_msm_gem_info req = { 0 };
- memset(&req, 0, sizeof(req));
req.handle = bo->handles[0].u32;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MSM_GEM_INFO, &req);
if (ret) {
drv_log("DRM_IOCLT_MSM_GEM_INFO failed with %s\n", strerror(errno));
+++ /dev/null
-/*
- * Copyright 2016 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 "drv_priv.h"
-#include "helpers.h"
-#include "util.h"
-
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888 };
-
-static int nouveau_init(struct driver *drv)
-{
- drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
- &LINEAR_METADATA, BO_USE_RENDER_MASK);
-
- return drv_modify_linear_combinations(drv);
-}
-
-const struct backend backend_nouveau = {
- .name = "nouveau",
- .init = nouveau_init,
- .bo_create = drv_dumb_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
-};
+++ /dev/null
-/*
- * 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 "drv_priv.h"
-#include "helpers.h"
-#include "util.h"
-
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888 };
-
-static int radeon_init(struct driver *drv)
-{
- drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
- &LINEAR_METADATA, BO_USE_RENDER_MASK);
-
- return drv_modify_linear_combinations(drv);
-}
-
-const struct backend backend_radeon = {
- .name = "radeon",
- .init = radeon_init,
- .bo_create = drv_dumb_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
-};
*/
drv_add_combination(drv, DRM_FORMAT_R8, &metadata,
BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE | BO_USE_SW_MASK |
- BO_USE_LINEAR | BO_USE_PROTECTED | BO_USE_HW_VIDEO_DECODER |
- BO_USE_HW_VIDEO_ENCODER);
+ BO_USE_LINEAR | BO_USE_HW_VIDEO_DECODER | BO_USE_HW_VIDEO_ENCODER);
return 0;
}
{
int ret;
size_t plane;
- struct drm_rockchip_gem_create gem_create;
+ struct drm_rockchip_gem_create gem_create = { 0 };
if (format == DRM_FORMAT_NV12) {
uint32_t w_mbs = DIV_ROUND_UP(width, 16);
drv_bo_from_format(bo, stride, height, format);
}
- memset(&gem_create, 0, sizeof(gem_create));
gem_create.size = bo->meta.total_size;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_ROCKCHIP_GEM_CREATE, &gem_create);
if (ret) {
static void *rockchip_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
{
int ret;
- struct drm_rockchip_gem_map_off gem_map;
struct rockchip_private_map_data *priv;
+ struct drm_rockchip_gem_map_off gem_map = { 0 };
/* We can only map buffers created with SW access flags, which should
* have no modifiers (ie, not AFBC). */
if (bo->meta.format_modifiers[0] == DRM_FORMAT_MOD_CHROMEOS_ROCKCHIP_AFBC)
return MAP_FAILED;
- memset(&gem_map, 0, sizeof(gem_map));
gem_map.handle = bo->handles[0].u32;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_ROCKCHIP_GEM_MAP_OFFSET, &gem_map);
if (ret) {
drv_log("DRM_IOCTL_ROCKCHIP_GEM_MAP_OFFSET failed\n");
+++ /dev/null
-/*
- * Copyright 2020 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.
- */
-#ifdef DRV_SYNAPTICS
-
-#include "drv_priv.h"
-#include "helpers.h"
-#include "util.h"
-
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_ABGR8888,
- DRM_FORMAT_XRGB8888 };
-
-static const uint32_t texture_source_formats[] = { DRM_FORMAT_R8, DRM_FORMAT_NV12,
- DRM_FORMAT_YVU420, DRM_FORMAT_YVU420_ANDROID };
-
-static int synaptics_init(struct driver *drv)
-{
- drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
- &LINEAR_METADATA, BO_USE_RENDER_MASK | BO_USE_SCANOUT);
-
- drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
- &LINEAR_METADATA, BO_USE_TEXTURE_MASK | BO_USE_HW_VIDEO_ENCODER);
-
- return drv_modify_linear_combinations(drv);
-}
-
-const struct backend backend_synaptics = {
- .name = "synaptics",
- .init = synaptics_init,
- .bo_create = drv_dumb_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
-};
-
-#endif
{
uint32_t size, stride, block_height_log2 = 0;
enum nv_mem_kind kind = NV_MEM_KIND_PITCH;
- struct drm_tegra_gem_create gem_create;
+ struct drm_tegra_gem_create gem_create = { 0 };
int ret;
if (use_flags &
compute_layout_blocklinear(width, height, format, &kind, &block_height_log2,
&stride, &size);
- memset(&gem_create, 0, sizeof(gem_create));
gem_create.size = size;
gem_create.flags = 0;
bo->meta.strides[0] = stride;
if (kind != NV_MEM_KIND_PITCH) {
- struct drm_tegra_gem_set_tiling gem_tile;
+ struct drm_tegra_gem_set_tiling gem_tile = { 0 };
- memset(&gem_tile, 0, sizeof(gem_tile));
gem_tile.handle = bo->handles[0].u32;
gem_tile.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK;
gem_tile.value = block_height_log2;
static int tegra_bo_import(struct bo *bo, struct drv_import_fd_data *data)
{
int ret;
- struct drm_tegra_gem_get_tiling gem_get_tiling;
+ struct drm_tegra_gem_get_tiling gem_get_tiling = { 0 };
ret = drv_prime_bo_import(bo, data);
if (ret)
return ret;
/* TODO(gsingh): export modifiers and get rid of backdoor tiling. */
- memset(&gem_get_tiling, 0, sizeof(gem_get_tiling));
gem_get_tiling.handle = bo->handles[0].u32;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_TEGRA_GEM_GET_TILING, &gem_get_tiling);
if (ret) {
drv_gem_bo_destroy(bo);
static void *tegra_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
{
int ret;
- struct drm_tegra_gem_mmap gem_map;
+ struct drm_tegra_gem_mmap gem_map = { 0 };
struct tegra_private_map_data *priv;
- memset(&gem_map, 0, sizeof(gem_map));
gem_map.handle = bo->handles[0].u32;
-
ret = drmCommandWriteRead(bo->drv->fd, DRM_TEGRA_GEM_MMAP, &gem_map, sizeof(gem_map));
if (ret < 0) {
drv_log("DRM_TEGRA_GEM_MMAP failed\n");
+++ /dev/null
-/*
- * Copyright 2014 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 "drv_priv.h"
-#include "helpers.h"
-#include "util.h"
-
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888 };
-
-static int udl_init(struct driver *drv)
-{
- drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
- &LINEAR_METADATA, BO_USE_RENDER_MASK);
-
- return drv_modify_linear_combinations(drv);
-}
-
-const struct backend backend_udl = {
- .name = "udl",
- .init = udl_init,
- .bo_create = drv_dumb_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
-};
static const uint32_t render_target_formats[] = { DRM_FORMAT_ARGB8888, DRM_FORMAT_RGB565,
DRM_FORMAT_XRGB8888 };
+static const uint32_t texture_only_formats[] = { DRM_FORMAT_NV12, DRM_FORMAT_YVU420 };
+
static int vc4_init(struct driver *drv)
{
drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
&LINEAR_METADATA, BO_USE_RENDER_MASK);
+ drv_add_combinations(drv, texture_only_formats, ARRAY_SIZE(texture_only_formats),
+ &LINEAR_METADATA, BO_USE_TEXTURE_MASK);
+ /*
+ * Chrome uses DMA-buf mmap to write to YV12 buffers, which are then accessed by the
+ * Video Encoder Accelerator (VEA). It could also support NV12 potentially in the future.
+ */
+ drv_modify_combination(drv, DRM_FORMAT_YVU420, &LINEAR_METADATA, BO_USE_HW_VIDEO_ENCODER);
+ drv_modify_combination(drv, DRM_FORMAT_NV12, &LINEAR_METADATA,
+ BO_USE_HW_VIDEO_DECODER | BO_USE_SCANOUT | BO_USE_HW_VIDEO_ENCODER);
+
return drv_modify_linear_combinations(drv);
}
int ret;
size_t plane;
uint32_t stride;
- struct drm_vc4_create_bo bo_create;
+ struct drm_vc4_create_bo bo_create = { 0 };
switch (modifier) {
case DRM_FORMAT_MOD_LINEAR:
stride = ALIGN(stride, 64);
drv_bo_from_format(bo, stride, height, format);
- memset(&bo_create, 0, sizeof(bo_create));
bo_create.size = bo->meta.total_size;
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VC4_CREATE_BO, &bo_create);
static void *vc4_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
{
int ret;
- struct drm_vc4_mmap_bo bo_map;
+ struct drm_vc4_mmap_bo bo_map = { 0 };
- memset(&bo_map, 0, sizeof(bo_map));
bo_map.handle = bo->handles[0].u32;
-
ret = drmCommandWriteRead(bo->drv->fd, DRM_VC4_MMAP_BO, &bo_map, sizeof(bo_map));
if (ret) {
drv_log("DRM_VC4_MMAP_BO failed\n");
+++ /dev/null
-/*
- * Copyright 2016 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 "drv_priv.h"
-#include "helpers.h"
-#include "util.h"
-
-#define MESA_LLVMPIPE_TILE_ORDER 6
-#define MESA_LLVMPIPE_TILE_SIZE (1 << MESA_LLVMPIPE_TILE_ORDER)
-
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ABGR8888, DRM_FORMAT_ARGB8888,
- DRM_FORMAT_RGB565, DRM_FORMAT_XBGR8888,
- DRM_FORMAT_XRGB8888 };
-
-static const uint32_t texture_source_formats[] = { DRM_FORMAT_R8, DRM_FORMAT_YVU420,
- DRM_FORMAT_YVU420_ANDROID };
-
-static int vgem_init(struct driver *drv)
-{
- drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
- &LINEAR_METADATA, BO_USE_RENDER_MASK);
-
- drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
- &LINEAR_METADATA, BO_USE_TEXTURE_MASK);
-
- return drv_modify_linear_combinations(drv);
-}
-
-static int vgem_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
- uint64_t flags)
-{
- width = ALIGN(width, MESA_LLVMPIPE_TILE_SIZE);
- height = ALIGN(height, MESA_LLVMPIPE_TILE_SIZE);
-
- return drv_dumb_bo_create(bo, width, height, format, flags);
-}
-
-static uint32_t vgem_resolve_format(struct driver *drv, uint32_t format, uint64_t flags)
-{
- switch (format) {
- case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
- /*HACK: See b/28671744 */
- return DRM_FORMAT_XBGR8888;
- case DRM_FORMAT_FLEX_YCbCr_420_888:
- return DRM_FORMAT_YVU420;
- default:
- return format;
- }
-}
-
-const struct backend backend_vgem = {
- .name = "vgem",
- .init = vgem_init,
- .bo_create = vgem_bo_create,
- .bo_destroy = drv_dumb_bo_destroy,
- .bo_import = drv_prime_bo_import,
- .bo_map = drv_dumb_bo_map,
- .bo_unmap = drv_bo_munmap,
- .resolve_format = vgem_resolve_format,
-};
int ret;
size_t i;
uint32_t stride;
- struct drm_virtgpu_resource_create res_create;
+ struct drm_virtgpu_resource_create res_create = { 0 };
struct bo_metadata emulated_metadata;
if (virtio_gpu_supports_combination_natively(bo->drv, format, use_flags)) {
* virglrenderer. When virglrenderer makes a resource, it will convert the target
* enum to the equivalent one in GL and then bind the resource to that target.
*/
- memset(&res_create, 0, sizeof(res_create));
res_create.target = PIPE_TEXTURE_2D;
res_create.format = translate_format(format);
static void *virtio_virgl_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
{
int ret;
- struct drm_virtgpu_map gem_map;
+ struct drm_virtgpu_map gem_map = { 0 };
- memset(&gem_map, 0, sizeof(gem_map));
gem_map.handle = bo->handles[0].u32;
-
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_MAP, &gem_map);
if (ret) {
drv_log("DRM_IOCTL_VIRTGPU_MAP failed with %s\n", strerror(errno));
static int virtio_gpu_get_caps(struct driver *drv, union virgl_caps *caps, int *caps_is_v2)
{
int ret;
- struct drm_virtgpu_get_caps cap_args;
+ struct drm_virtgpu_get_caps cap_args = { 0 };
*caps_is_v2 = 0;
- memset(&cap_args, 0, sizeof(cap_args));
cap_args.addr = (unsigned long long)caps;
if (features[feat_capset_fix].enabled) {
*caps_is_v2 = 1;
uint32_t cmd[VIRGL_PIPE_RES_CREATE_SIZE + 1] = { 0 };
struct drm_virtgpu_resource_create_blob drm_rc_blob = { 0 };
- uint32_t blob_flags = VIRTGPU_BLOB_FLAG_USE_MAPPABLE | VIRTGPU_BLOB_FLAG_USE_SHAREABLE;
- if (bo->meta.use_flags & BO_USE_NON_GPU_HW) {
+ uint32_t blob_flags = VIRTGPU_BLOB_FLAG_USE_SHAREABLE;
+ if (bo->meta.use_flags & BO_USE_SW_MASK)
+ blob_flags |= VIRTGPU_BLOB_FLAG_USE_MAPPABLE;
+ if (bo->meta.use_flags & BO_USE_NON_GPU_HW)
blob_flags |= VIRTGPU_BLOB_FLAG_USE_CROSS_DEVICE;
- }
stride = drv_stride_from_format(bo->meta.format, bo->meta.width, 0);
drv_bo_from_format(bo, stride, bo->meta.height, bo->meta.format);
if (!priv->host_gbm_enabled)
return false;
- // Focus on non-GPU apps for now
- if (use_flags & (BO_USE_RENDERING | BO_USE_TEXTURE))
+ // Use regular resources if only the GPU needs efficient access
+ if (!(use_flags &
+ (BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN | BO_USE_LINEAR | BO_USE_NON_GPU_HW)))
return false;
- // Simple, strictly defined formats for now
- if (format != DRM_FORMAT_YVU420_ANDROID && format != DRM_FORMAT_R8)
- return false;
-
- if (use_flags &
- (BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN | BO_USE_LINEAR | BO_USE_NON_GPU_HW))
+ switch (format) {
+ case DRM_FORMAT_YVU420_ANDROID:
+ case DRM_FORMAT_R8:
+ // Formats with strictly defined strides are supported
return true;
-
- return false;
+ case DRM_FORMAT_NV12:
+ // Knowing buffer metadata at buffer creation isn't yet supported, so buffers
+ // can't be properly mapped into the guest.
+ return (use_flags & BO_USE_SW_MASK) == 0;
+ default:
+ return false;
+ }
}
static int virtio_gpu_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
{
int ret;
size_t i;
- struct drm_virtgpu_3d_transfer_from_host xfer;
- struct drm_virtgpu_3d_wait waitcmd;
+ struct drm_virtgpu_3d_transfer_from_host xfer = { 0 };
+ struct drm_virtgpu_3d_wait waitcmd = { 0 };
struct virtio_transfers_params xfer_params;
struct virtio_gpu_priv *priv = (struct virtio_gpu_priv *)bo->drv->priv;
(bo->meta.tiling & VIRTGPU_BLOB_FLAG_USE_MAPPABLE))
return 0;
- memset(&xfer, 0, sizeof(xfer));
xfer.bo_handle = mapping->vma->handle;
if (mapping->rect.x || mapping->rect.y) {
// The transfer needs to complete before invalidate returns so that any host changes
// are visible and to ensure the host doesn't overwrite subsequent guest changes.
// TODO(b/136733358): Support returning fences from transfers
- memset(&waitcmd, 0, sizeof(waitcmd));
waitcmd.handle = mapping->vma->handle;
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_WAIT, &waitcmd);
if (ret) {
{
int ret;
size_t i;
- struct drm_virtgpu_3d_transfer_to_host xfer;
- struct drm_virtgpu_3d_wait waitcmd;
+ struct drm_virtgpu_3d_transfer_to_host xfer = { 0 };
+ struct drm_virtgpu_3d_wait waitcmd = { 0 };
struct virtio_transfers_params xfer_params;
struct virtio_gpu_priv *priv = (struct virtio_gpu_priv *)bo->drv->priv;
(bo->meta.tiling & VIRTGPU_BLOB_FLAG_USE_MAPPABLE))
return 0;
- memset(&xfer, 0, sizeof(xfer));
xfer.bo_handle = mapping->vma->handle;
if (mapping->rect.x || mapping->rect.y) {
// buffer, we need to wait for the transfer to complete for consistency.
// TODO(b/136733358): Support returning fences from transfers
if (bo->meta.use_flags & BO_USE_NON_GPU_HW) {
- memset(&waitcmd, 0, sizeof(waitcmd));
waitcmd.handle = mapping->vma->handle;
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_WAIT, &waitcmd);
uint32_t offsets[DRV_MAX_PLANES])
{
int ret;
- struct drm_virtgpu_resource_info res_info;
+ struct drm_virtgpu_resource_info res_info = { 0 };
if (!features[feat_3d].enabled)
return 0;
- memset(&res_info, 0, sizeof(res_info));
res_info.bo_handle = bo->handles[0].u32;
ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_RESOURCE_INFO, &res_info);
if (ret) {
OSDN Git Service
