BASELINE: Update Chromium to 78.0.3904.130

Change-Id: If185e0c0061b3437531c97c9c8c78f239352a68b
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

23 files changed, 403 insertions, 72 deletions

diff --git a/chromium/third_party/minigbm/OWNERS b/chromium/third_party/minigbm/OWNERS
index 6223bd56e36..437b03dcc01 100644
--- a/chromium/third_party/minigbm/OWNERS
+++ b/chromium/third_party/minigbm/OWNERS
@@ -3,3 +3,4 @@ spang@chromium.org
 gurchetansingh@chromium.org
 servolk@chromium.org
 dnicoara@chromium.org
+# COMPONENT: Internals>GPU
diff --git a/chromium/third_party/minigbm/src/Android.mk b/chromium/third_party/minigbm/src/Android.mk
index 9169cefba0c..564f416f691 100644
--- a/chromium/third_party/minigbm/src/Android.mk
+++ b/chromium/third_party/minigbm/src/Android.mk
@@ -9,6 +9,7 @@ intel_drivers := i915 i965
 
 MINIGBM_SRC := \
 	amdgpu.c \
+	dri.c \
 	drv.c \
 	evdi.c \
 	exynos.c \
diff --git a/chromium/third_party/minigbm/src/OWNERS b/chromium/third_party/minigbm/src/OWNERS
new file mode 100644
index 00000000000..a6feb041243
--- /dev/null
+++ b/chromium/third_party/minigbm/src/OWNERS
@@ -0,0 +1,8 @@
+marcheu@chromium.org
+gurchetansingh@chromium.org
+hoegsberg@chromium.org
+tfiga@chromium.org
+ddavenport@chromium.org
+dbehr@chromium.org
+dcastagna@chromium.org
+lepton@chromium.org
diff --git a/chromium/third_party/minigbm/src/amdgpu.c b/chromium/third_party/minigbm/src/amdgpu.c
index fabedf3b4ed..65dd8644f45 100644
--- a/chromium/third_party/minigbm/src/amdgpu.c
+++ b/chromium/third_party/minigbm/src/amdgpu.c
@@ -37,8 +37,9 @@ const static uint32_t render_target_formats[] = { DRM_FORMAT_ABGR8888, DRM_FORMA
 						  DRM_FORMAT_RGB565, DRM_FORMAT_XBGR8888,
 						  DRM_FORMAT_XRGB8888 };
 
-const static uint32_t texture_source_formats[] = { DRM_FORMAT_GR88, DRM_FORMAT_R8, DRM_FORMAT_NV21,
-						   DRM_FORMAT_NV12, DRM_FORMAT_YVU420_ANDROID };
+const static uint32_t texture_source_formats[] = { DRM_FORMAT_GR88,	      DRM_FORMAT_R8,
+						   DRM_FORMAT_NV21,	      DRM_FORMAT_NV12,
+						   DRM_FORMAT_YVU420_ANDROID, DRM_FORMAT_YVU420 };
 
 static int amdgpu_init(struct driver *drv)
 {
@@ -78,12 +79,20 @@ static int amdgpu_init(struct driver *drv)
 	drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
 			     &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, &metadata, BO_USE_HW_VIDEO_ENCODER);
+	drv_modify_combination(drv, DRM_FORMAT_NV12, &metadata, BO_USE_HW_VIDEO_ENCODER);
+
 	/* Android CTS tests require this. */
 	drv_add_combination(drv, DRM_FORMAT_BGR888, &metadata, BO_USE_SW_MASK);
 
 	/* Linear formats supported by display. */
 	drv_modify_combination(drv, DRM_FORMAT_ARGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
 	drv_modify_combination(drv, DRM_FORMAT_XRGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
+	drv_modify_combination(drv, DRM_FORMAT_ABGR8888, &metadata, BO_USE_SCANOUT);
 	drv_modify_combination(drv, DRM_FORMAT_XBGR8888, &metadata, BO_USE_SCANOUT);
 
 	/* YUV formats for camera and display. */
@@ -119,6 +128,7 @@ static int amdgpu_init(struct driver *drv)
 	/* Potentially tiled formats supported by display. */
 	drv_modify_combination(drv, DRM_FORMAT_ARGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
 	drv_modify_combination(drv, DRM_FORMAT_XRGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
+	drv_modify_combination(drv, DRM_FORMAT_ABGR8888, &metadata, BO_USE_SCANOUT);
 	drv_modify_combination(drv, DRM_FORMAT_XBGR8888, &metadata, BO_USE_SCANOUT);
 	return 0;
 }
@@ -274,7 +284,7 @@ static int amdgpu_bo_invalidate(struct bo *bo, struct mapping *mapping)
 	return 0;
 }
 
-static uint32_t amdgpu_resolve_format(uint32_t format, uint64_t use_flags)
+static uint32_t amdgpu_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
 	switch (format) {
 	case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
diff --git a/chromium/third_party/minigbm/src/cros_gralloc/cros_gralloc_driver.cc b/chromium/third_party/minigbm/src/cros_gralloc/cros_gralloc_driver.cc
index 8096b7ff55b..8a63864d2cb 100644
--- a/chromium/third_party/minigbm/src/cros_gralloc/cros_gralloc_driver.cc
+++ b/chromium/third_party/minigbm/src/cros_gralloc/cros_gralloc_driver.cc
@@ -21,8 +21,10 @@ cros_gralloc_driver::~cros_gralloc_driver()
 	handles_.clear();
 
 	if (drv_) {
+		int fd = drv_get_fd(drv_);
 		drv_destroy(drv_);
 		drv_ = nullptr;
+		close(fd);
 	}
 }
 
@@ -56,10 +58,13 @@ int32_t cros_gralloc_driver::init()
 				continue;
 
 			version = drmGetVersion(fd);
-			if (!version)
+			if (!version) {
+				close(fd);
 				continue;
+			}
 
 			if (undesired[i] && !strcmp(version->name, undesired[i])) {
+				close(fd);
 				drmFreeVersion(version);
 				continue;
 			}
@@ -68,6 +73,8 @@ int32_t cros_gralloc_driver::init()
 			drv_ = drv_create(fd);
 			if (drv_)
 				return 0;
+
+			close(fd);
 		}
 	}
 
diff --git a/chromium/third_party/minigbm/src/drv.c b/chromium/third_party/minigbm/src/drv.c
index 09f303c20cd..fa157ef00e2 100644
--- a/chromium/third_party/minigbm/src/drv.c
+++ b/chromium/third_party/minigbm/src/drv.c
@@ -111,8 +111,7 @@ static const struct backend *drv_get_backend(int fd)
 #ifdef DRV_VC4
 		&backend_vc4,
 #endif
-		&backend_vgem,
-		&backend_virtio_gpu,
+		&backend_vgem,	   &backend_virtio_gpu,
 	};
 
 	for (i = 0; i < ARRAY_SIZE(backend_list); i++)
@@ -607,7 +606,7 @@ uint32_t drv_bo_get_format(struct bo *bo)
 uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
 	if (drv->backend->resolve_format)
-		return drv->backend->resolve_format(format, use_flags);
+		return drv->backend->resolve_format(drv, format, use_flags);
 
 	return format;
 }
diff --git a/chromium/third_party/minigbm/src/drv.h b/chromium/third_party/minigbm/src/drv.h
index d27e8459098..d3cf9d3e041 100644
--- a/chromium/third_party/minigbm/src/drv.h
+++ b/chromium/third_party/minigbm/src/drv.h
@@ -56,6 +56,11 @@ extern "C" {
 #define DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED	fourcc_code('9', '9', '9', '8')
 #define DRM_FORMAT_FLEX_YCbCr_420_888		fourcc_code('9', '9', '9', '9')
 
+// TODO(crbug.com/958181): remove this definition once drm_fourcc.h contains it.
+#ifndef DRM_FORMAT_P010
+#define DRM_FORMAT_P010 fourcc_code('P', '0', '1', '0')
+#endif
+
 // clang-format on
 struct driver;
 struct bo;
diff --git a/chromium/third_party/minigbm/src/drv_priv.h b/chromium/third_party/minigbm/src/drv_priv.h
index d1369f02654..46e64905796 100644
--- a/chromium/third_party/minigbm/src/drv_priv.h
+++ b/chromium/third_party/minigbm/src/drv_priv.h
@@ -73,7 +73,7 @@ struct backend {
 	int (*bo_unmap)(struct bo *bo, struct vma *vma);
 	int (*bo_invalidate)(struct bo *bo, struct mapping *mapping);
 	int (*bo_flush)(struct bo *bo, struct mapping *mapping);
-	uint32_t (*resolve_format)(uint32_t format, uint64_t use_flags);
+	uint32_t (*resolve_format)(struct driver *drv, uint32_t format, uint64_t use_flags);
 };
 
 // clang-format off
diff --git a/chromium/third_party/minigbm/src/exynos.c b/chromium/third_party/minigbm/src/exynos.c
index cf95b38ea10..b2b4040db32 100644
--- a/chromium/third_party/minigbm/src/exynos.c
+++ b/chromium/third_party/minigbm/src/exynos.c
@@ -73,6 +73,7 @@ static int exynos_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint
 		ret = drmIoctl(bo->drv->fd, DRM_IOCTL_EXYNOS_GEM_CREATE, &gem_create);
 		if (ret) {
 			drv_log("DRM_IOCTL_EXYNOS_GEM_CREATE failed (size=%zu)\n", size);
+			ret = -errno;
 			goto cleanup_planes;
 		}
 
diff --git a/chromium/third_party/minigbm/src/gbm.c b/chromium/third_party/minigbm/src/gbm.c
index 4e41daa9ae3..7f9ed995638 100644
--- a/chromium/third_party/minigbm/src/gbm.c
+++ b/chromium/third_party/minigbm/src/gbm.c
@@ -188,9 +188,12 @@ PUBLIC struct gbm_bo *gbm_bo_import(struct gbm_device *gbm, uint32_t type, void
 		drv_data.height = fd_modifier_data->height;
 		drv_data.format = fd_modifier_data->format;
 		num_planes = drv_num_planes_from_format(drv_data.format);
+		assert(num_planes);
+
 		num_fds = fd_modifier_data->num_fds;
+		if (!num_fds || num_fds > num_planes)
+			return NULL;
 
-		assert(num_fds > 0 && num_fds <= num_planes);
 		for (i = 0; i < num_planes; i++) {
 			if (num_fds != num_planes)
 				drv_data.fds[i] = fd_modifier_data->fds[0];
@@ -267,7 +270,7 @@ PUBLIC void *gbm_bo_map(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t widt
 	*stride = ((struct mapping *)*map_data)->vma->map_strides[plane];
 
 	offset = *stride * rect.y;
-	offset += drv_stride_from_format(bo->gbm_format, rect.x, plane);
+	offset += rect.x * drv_bytes_per_pixel_from_format(bo->gbm_format, plane);
 	return (void *)((uint8_t *)addr + offset);
 }
 
diff --git a/chromium/third_party/minigbm/src/gbm.h b/chromium/third_party/minigbm/src/gbm.h
index 61505302a69..a2f10f64553 100644
--- a/chromium/third_party/minigbm/src/gbm.h
+++ b/chromium/third_party/minigbm/src/gbm.h
@@ -273,6 +273,10 @@ enum gbm_bo_flags {
     * The buffer will be written by a video decode accelerator.
     */
    GBM_BO_USE_HW_VIDEO_DECODER = (1 << 13),
+   /**
+    * The buffer will be read by a video encode accelerator.
+    */
+   GBM_BO_USE_HW_VIDEO_ENCODER = (1 << 14),
 };
 
 int
diff --git a/chromium/third_party/minigbm/src/gbm_helpers.c b/chromium/third_party/minigbm/src/gbm_helpers.c
index 81d1680e91f..0626a6d4c98 100644
--- a/chromium/third_party/minigbm/src/gbm_helpers.c
+++ b/chromium/third_party/minigbm/src/gbm_helpers.c
@@ -42,6 +42,8 @@ uint64_t gbm_convert_usage(uint32_t usage)
 		use_flags |= BO_USE_SW_WRITE_RARELY;
 	if (usage & GBM_BO_USE_HW_VIDEO_DECODER)
 		use_flags |= BO_USE_HW_VIDEO_DECODER;
+	if (usage & GBM_BO_USE_HW_VIDEO_ENCODER)
+		use_flags |= BO_USE_HW_VIDEO_ENCODER;
 
 	return use_flags;
 }
diff --git a/chromium/third_party/minigbm/src/helpers.c b/chromium/third_party/minigbm/src/helpers.c
index 6dbc7cea0e8..992eeb74290 100644
--- a/chromium/third_party/minigbm/src/helpers.c
+++ b/chromium/third_party/minigbm/src/helpers.c
@@ -6,7 +6,6 @@
 
 #include <assert.h>
 #include <errno.h>
-#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -69,6 +68,13 @@ static const struct planar_layout triplanar_yuv_420_layout = {
 	.bytes_per_pixel = { 1, 1, 1 }
 };
 
+static const struct planar_layout biplanar_yuv_p010_layout = {
+	.num_planes = 2,
+	.horizontal_subsampling = { 1, 2 },
+	.vertical_subsampling = { 1, 2 },
+	.bytes_per_pixel = { 2, 4 }
+};
+
 // clang-format on
 
 static const struct planar_layout *layout_from_format(uint32_t format)
@@ -88,6 +94,9 @@ static const struct planar_layout *layout_from_format(uint32_t format)
 	case DRM_FORMAT_NV21:
 		return &biplanar_yuv_420_layout;
 
+	case DRM_FORMAT_P010:
+		return &biplanar_yuv_p010_layout;
+
 	case DRM_FORMAT_ABGR1555:
 	case DRM_FORMAT_ABGR4444:
 	case DRM_FORMAT_ARGB1555:
@@ -290,7 +299,7 @@ int drv_dumb_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
 	if (ret) {
 		drv_log("DRM_IOCTL_MODE_CREATE_DUMB failed (%d, %d)\n", bo->drv->fd, errno);
-		return ret;
+		return -errno;
 	}
 
 	drv_bo_from_format(bo, create_dumb.pitch, height, format);
@@ -313,7 +322,7 @@ int drv_dumb_bo_destroy(struct bo *bo)
 	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);
-		return ret;
+		return -errno;
 	}
 
 	return 0;
@@ -340,7 +349,7 @@ int drv_gem_bo_destroy(struct bo *bo)
 		if (ret) {
 			drv_log("DRM_IOCTL_GEM_CLOSE failed (handle=%x) error %d\n",
 				bo->handles[plane].u32, ret);
-			error = ret;
+			error = -errno;
 		}
 	}
 
@@ -370,7 +379,7 @@ int drv_prime_bo_import(struct bo *bo, struct drv_import_fd_data *data)
 			 */
 			bo->num_planes = plane;
 			drv_gem_bo_destroy(bo);
-			return ret;
+			return -errno;
 		}
 
 		bo->handles[plane].u32 = prime_handle.handle;
@@ -522,7 +531,8 @@ void drv_modify_combination(struct driver *drv, uint32_t format, struct format_m
 struct drv_array *drv_query_kms(struct driver *drv)
 {
 	struct drv_array *kms_items;
-	uint64_t plane_type, use_flag;
+	uint64_t plane_type = UINT64_MAX;
+        uint64_t use_flag;
 	uint32_t i, j, k;
 
 	drmModePlanePtr plane;
@@ -549,6 +559,7 @@ struct drv_array *drv_query_kms(struct driver *drv)
 		goto out;
 
 	for (i = 0; i < resources->count_planes; i++) {
+		plane_type = UINT64_MAX;
 		plane = drmModeGetPlane(drv->fd, resources->planes[i]);
 		if (!plane)
 			goto out;
@@ -670,3 +681,16 @@ uint64_t drv_pick_modifier(const uint64_t *modifiers, uint32_t count,
 
 	return DRM_FORMAT_MOD_LINEAR;
 }
+
+/*
+ * Search a list of modifiers to see if a given modifier is present
+ */
+bool drv_has_modifier(const uint64_t *list, uint32_t count, uint64_t modifier)
+{
+	uint32_t i;
+	for (i = 0; i < count; i++)
+		if (list[i] == modifier)
+			return true;
+
+	return false;
+}
diff --git a/chromium/third_party/minigbm/src/helpers.h b/chromium/third_party/minigbm/src/helpers.h
index 4f68c3ba6fd..c09d2c24a62 100644
--- a/chromium/third_party/minigbm/src/helpers.h
+++ b/chromium/third_party/minigbm/src/helpers.h
@@ -7,6 +7,8 @@
 #ifndef HELPERS_H
 #define HELPERS_H
 
+#include <stdbool.h>
+
 #include "drv.h"
 #include "helpers_array.h"
 
@@ -35,4 +37,5 @@ struct drv_array *drv_query_kms(struct driver *drv);
 int drv_modify_linear_combinations(struct driver *drv);
 uint64_t drv_pick_modifier(const uint64_t *modifiers, uint32_t count,
 			   const uint64_t *modifier_order, uint32_t order_count);
+bool drv_has_modifier(const uint64_t *list, uint32_t count, uint64_t modifier);
 #endif
diff --git a/chromium/third_party/minigbm/src/i915.c b/chromium/third_party/minigbm/src/i915.c
index 43e72c2d9b9..9683bf0a2d0 100644
--- a/chromium/third_party/minigbm/src/i915.c
+++ b/chromium/third_party/minigbm/src/i915.c
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
+#include <unistd.h>
 #include <xf86drm.h>
 
 #include "drv_priv.h"
@@ -22,17 +23,17 @@
 #define I915_CACHELINE_SIZE 64
 #define I915_CACHELINE_MASK (I915_CACHELINE_SIZE - 1)
 
-static const uint32_t render_target_formats[] = { DRM_FORMAT_ABGR8888,    DRM_FORMAT_ARGB1555,
-						  DRM_FORMAT_ARGB8888,    DRM_FORMAT_RGB565,
+static const uint32_t render_target_formats[] = { DRM_FORMAT_ABGR8888,	  DRM_FORMAT_ARGB1555,
+						  DRM_FORMAT_ARGB8888,	  DRM_FORMAT_RGB565,
 						  DRM_FORMAT_XBGR2101010, DRM_FORMAT_XBGR8888,
-						  DRM_FORMAT_XRGB1555,    DRM_FORMAT_XRGB2101010,
-						  DRM_FORMAT_XRGB8888 };
+						  DRM_FORMAT_XRGB1555,	  DRM_FORMAT_XRGB2101010,
+						  DRM_FORMAT_XRGB8888,	  DRM_FORMAT_ARGB2101010 };
 
 static const uint32_t tileable_texture_source_formats[] = { DRM_FORMAT_GR88, DRM_FORMAT_R8,
 							    DRM_FORMAT_UYVY, DRM_FORMAT_YUYV };
 
 static const uint32_t texture_source_formats[] = { DRM_FORMAT_YVU420, DRM_FORMAT_YVU420_ANDROID,
-						   DRM_FORMAT_NV12 };
+						   DRM_FORMAT_NV12, DRM_FORMAT_P010 };
 
 struct i915_device {
 	uint32_t gen;
@@ -137,6 +138,13 @@ static int i915_add_combinations(struct driver *drv)
 			     ARRAY_SIZE(tileable_texture_source_formats), &metadata,
 			     texture_use_flags);
 
+	/*
+	 * 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, &metadata, BO_USE_HW_VIDEO_ENCODER);
+	drv_modify_combination(drv, DRM_FORMAT_NV12, &metadata, BO_USE_HW_VIDEO_ENCODER);
+
 	/* Android CTS tests require this. */
 	drv_add_combination(drv, DRM_FORMAT_BGR888, &metadata, BO_USE_SW_MASK);
 
@@ -187,9 +195,11 @@ static int i915_add_combinations(struct driver *drv)
 			     ARRAY_SIZE(tileable_texture_source_formats), &metadata,
 			     texture_use_flags);
 
-	/* Support y-tiled NV12 for libva */
+	/* Support y-tiled NV12 and P010 for libva */
 	drv_add_combination(drv, DRM_FORMAT_NV12, &metadata,
 			    BO_USE_TEXTURE | BO_USE_HW_VIDEO_DECODER);
+	drv_add_combination(drv, DRM_FORMAT_P010, &metadata,
+			    BO_USE_TEXTURE | BO_USE_HW_VIDEO_DECODER);
 
 	kms_items = drv_query_kms(drv);
 	if (!kms_items)
@@ -314,15 +324,16 @@ static int i915_bo_from_format(struct bo *bo, uint32_t width, uint32_t height, u
 {
 	uint32_t offset;
 	size_t plane;
-	int ret;
+	int ret, pagesize;
 
 	offset = 0;
+	pagesize = getpagesize();
 	for (plane = 0; plane < drv_num_planes_from_format(format); plane++) {
 		uint32_t stride = drv_stride_from_format(format, width, plane);
 		uint32_t plane_height = drv_height_from_format(format, height, plane);
 
 		if (bo->tiling != I915_TILING_NONE)
-			assert(IS_ALIGNED(offset, 4096));
+			assert(IS_ALIGNED(offset, pagesize));
 
 		ret = i915_align_dimensions(bo, bo->tiling, &stride, &plane_height);
 		if (ret)
@@ -334,7 +345,7 @@ static int i915_bo_from_format(struct bo *bo, uint32_t width, uint32_t height, u
 		offset += bo->sizes[plane];
 	}
 
-	bo->total_size = offset;
+	bo->total_size = ALIGN(offset, pagesize);
 
 	return 0;
 }
@@ -382,7 +393,7 @@ static int i915_bo_create_for_modifier(struct bo *bo, uint32_t width, uint32_t h
 	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);
-		return ret;
+		return -errno;
 	}
 
 	for (plane = 0; plane < bo->num_planes; plane++)
@@ -557,7 +568,7 @@ static int i915_bo_flush(struct bo *bo, struct mapping *mapping)
 	return 0;
 }
 
-static uint32_t i915_resolve_format(uint32_t format, uint64_t use_flags)
+static uint32_t i915_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
 	switch (format) {
 	case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
diff --git a/chromium/third_party/minigbm/src/mediatek.c b/chromium/third_party/minigbm/src/mediatek.c
index 59a0facf52a..199d3cfb741 100644
--- a/chromium/third_party/minigbm/src/mediatek.c
+++ b/chromium/third_party/minigbm/src/mediatek.c
@@ -7,6 +7,7 @@
 #ifdef DRV_MEDIATEK
 
 // clang-format off
+#include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <stdio.h>
@@ -33,8 +34,14 @@ static const uint32_t render_target_formats[] = { DRM_FORMAT_ABGR8888, DRM_FORMA
 						  DRM_FORMAT_RGB565, DRM_FORMAT_XBGR8888,
 						  DRM_FORMAT_XRGB8888 };
 
+#ifdef MTK_MT8183
+static const uint32_t texture_source_formats[] = { DRM_FORMAT_R8,     DRM_FORMAT_NV21,
+						   DRM_FORMAT_NV12,   DRM_FORMAT_YUYV,
+						   DRM_FORMAT_YVU420, DRM_FORMAT_YVU420_ANDROID };
+#else
 static const uint32_t texture_source_formats[] = { DRM_FORMAT_R8, DRM_FORMAT_YVU420,
-						   DRM_FORMAT_YVU420_ANDROID };
+						   DRM_FORMAT_YVU420_ANDROID, DRM_FORMAT_NV12 };
+#endif
 
 static int mediatek_init(struct driver *drv)
 {
@@ -46,6 +53,13 @@ static int mediatek_init(struct driver *drv)
 	drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_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_ENCODER);
+
 	/* Android CTS tests require this. */
 	drv_add_combination(drv, DRM_FORMAT_BGR888, &LINEAR_METADATA, BO_USE_SW_MASK);
 
@@ -55,18 +69,40 @@ static int mediatek_init(struct driver *drv)
 	metadata.modifier = DRM_FORMAT_MOD_LINEAR;
 	drv_modify_combination(drv, DRM_FORMAT_YVU420, &metadata, BO_USE_HW_VIDEO_DECODER);
 	drv_modify_combination(drv, DRM_FORMAT_YVU420_ANDROID, &metadata, BO_USE_HW_VIDEO_DECODER);
+	drv_modify_combination(drv, DRM_FORMAT_NV12, &metadata, BO_USE_HW_VIDEO_DECODER);
+
+#ifdef MTK_MT8183
+	/* Only for MT8183 Camera subsystem */
+	drv_modify_combination(drv, DRM_FORMAT_NV12, &metadata,
+			       BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
+	drv_modify_combination(drv, DRM_FORMAT_NV21, &metadata,
+			       BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
+	drv_modify_combination(drv, DRM_FORMAT_YUYV, &metadata,
+			       BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
+	drv_modify_combination(drv, DRM_FORMAT_YVU420, &metadata,
+			       BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
+	drv_modify_combination(drv, DRM_FORMAT_R8, &metadata,
+			       BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
+#endif
 
 	return drv_modify_linear_combinations(drv);
 }
 
-static int mediatek_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-			      uint64_t use_flags)
+static int mediatek_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint32_t height,
+					     uint32_t format, const uint64_t *modifiers,
+					     uint32_t count)
 {
 	int ret;
 	size_t plane;
 	uint32_t stride;
 	struct drm_mtk_gem_create gem_create;
 
+	if (!drv_has_modifier(modifiers, count, DRM_FORMAT_MOD_LINEAR)) {
+		errno = EINVAL;
+		drv_log("no usable modifier found\n");
+		return -EINVAL;
+	}
+
 	/*
 	 * Since the ARM L1 cache line size is 64 bytes, align to that as a
 	 * performance optimization.
@@ -81,7 +117,7 @@ static int mediatek_bo_create(struct bo *bo, uint32_t width, uint32_t height, ui
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MTK_GEM_CREATE, &gem_create);
 	if (ret) {
 		drv_log("DRM_IOCTL_MTK_GEM_CREATE failed (size=%llu)\n", gem_create.size);
-		return ret;
+		return -errno;
 	}
 
 	for (plane = 0; plane < bo->num_planes; plane++)
@@ -90,6 +126,14 @@ static int mediatek_bo_create(struct bo *bo, uint32_t width, uint32_t height, ui
 	return 0;
 }
 
+static int mediatek_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
+			      uint64_t use_flags)
+{
+	uint64_t modifiers[] = { DRM_FORMAT_MOD_LINEAR };
+	return mediatek_bo_create_with_modifiers(bo, width, height, format, modifiers,
+						 ARRAY_SIZE(modifiers));
+}
+
 static void *mediatek_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
 {
 	int ret, prime_fd;
@@ -182,13 +226,23 @@ static int mediatek_bo_flush(struct bo *bo, struct mapping *mapping)
 	return 0;
 }
 
-static uint32_t mediatek_resolve_format(uint32_t format, uint64_t use_flags)
+static uint32_t mediatek_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
 	switch (format) {
 	case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
+#ifdef MTK_MT8183
+		/* Only for MT8183 Camera subsystem requires NV12. */
+		if (use_flags & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
+			return DRM_FORMAT_NV12;
+#endif
 		/*HACK: See b/28671744 */
 		return DRM_FORMAT_XBGR8888;
 	case DRM_FORMAT_FLEX_YCbCr_420_888:
+#ifdef MTK_MT8183
+		/* Only for MT8183 Camera subsystem requires NV12 */
+		if (use_flags & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
+			return DRM_FORMAT_NV12;
+#endif
 		return DRM_FORMAT_YVU420;
 	default:
 		return format;
@@ -199,6 +253,7 @@ const struct backend backend_mediatek = {
 	.name = "mediatek",
 	.init = mediatek_init,
 	.bo_create = mediatek_bo_create,
+	.bo_create_with_modifiers = mediatek_bo_create_with_modifiers,
 	.bo_destroy = drv_gem_bo_destroy,
 	.bo_import = drv_prime_bo_import,
 	.bo_map = mediatek_bo_map,
diff --git a/chromium/third_party/minigbm/src/msm.c b/chromium/third_party/minigbm/src/msm.c
index 085cfb0924d..a8df00000ce 100644
--- a/chromium/third_party/minigbm/src/msm.c
+++ b/chromium/third_party/minigbm/src/msm.c
@@ -9,6 +9,7 @@
 #include <assert.h>
 #include <drm_fourcc.h>
 #include <errno.h>
+#include <inttypes.h>
 #include <msm_drm.h>
 #include <stdbool.h>
 #include <stdio.h>
@@ -165,6 +166,13 @@ static int msm_init(struct driver *drv)
 	drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
 			     &LINEAR_METADATA, texture_use_flags);
 
+	/*
+	 * 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_ENCODER);
+
 	/* Android CTS tests require this. */
 	drv_add_combination(drv, DRM_FORMAT_BGR888, &LINEAR_METADATA, BO_USE_SW_MASK);
 
@@ -204,7 +212,7 @@ static int msm_bo_create_for_modifier(struct bo *bo, uint32_t width, uint32_t he
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MSM_GEM_NEW, &req);
 	if (ret) {
 		drv_log("DRM_IOCTL_MSM_GEM_NEW failed with %s\n", strerror(errno));
-		return ret;
+		return -errno;
 	}
 
 	/*
@@ -240,7 +248,7 @@ static int msm_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_
 	struct combination *combo = drv_get_combination(bo->drv, format, flags);
 
 	if (!combo) {
-		drv_log("invalid format = %d, flags = %llx combination\n", format, flags);
+		drv_log("invalid format = %d, flags = %" PRIx64 " combination\n", format, flags);
 		return -EINVAL;
 	}
 
diff --git a/chromium/third_party/minigbm/src/rockchip.c b/chromium/third_party/minigbm/src/rockchip.c
index 177f9c70c28..a1685af924f 100644
--- a/chromium/third_party/minigbm/src/rockchip.c
+++ b/chromium/third_party/minigbm/src/rockchip.c
@@ -8,7 +8,6 @@
 
 #include <errno.h>
 #include <rockchip_drm.h>
-#include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
@@ -122,6 +121,13 @@ static int rockchip_init(struct driver *drv)
 	drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
 			     &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, &metadata, BO_USE_HW_VIDEO_ENCODER);
+	drv_modify_combination(drv, DRM_FORMAT_NV12, &metadata, BO_USE_HW_VIDEO_ENCODER);
+
 	drv_modify_combination(drv, DRM_FORMAT_XRGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
 	drv_modify_combination(drv, DRM_FORMAT_ARGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
 
@@ -151,16 +157,6 @@ static int rockchip_init(struct driver *drv)
 	return 0;
 }
 
-static bool has_modifier(const uint64_t *list, uint32_t count, uint64_t modifier)
-{
-	uint32_t i;
-	for (i = 0; i < count; i++)
-		if (list[i] == modifier)
-			return true;
-
-	return false;
-}
-
 static int rockchip_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint32_t height,
 					     uint32_t format, const uint64_t *modifiers,
 					     uint32_t count)
@@ -170,21 +166,25 @@ static int rockchip_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint
 	struct drm_rockchip_gem_create gem_create;
 
 	if (format == DRM_FORMAT_NV12) {
-		uint32_t w_mbs = DIV_ROUND_UP(ALIGN(width, 16), 16);
-		uint32_t h_mbs = DIV_ROUND_UP(ALIGN(height, 16), 16);
+		uint32_t w_mbs = DIV_ROUND_UP(width, 16);
+		uint32_t h_mbs = DIV_ROUND_UP(height, 16);
 
 		uint32_t aligned_width = w_mbs * 16;
-		uint32_t aligned_height = DIV_ROUND_UP(h_mbs * 16 * 3, 2);
+		uint32_t aligned_height = h_mbs * 16;
 
-		drv_bo_from_format(bo, aligned_width, height, format);
-		bo->total_size = bo->strides[0] * aligned_height + w_mbs * h_mbs * 128;
+		drv_bo_from_format(bo, aligned_width, aligned_height, format);
+		/*
+		 * drv_bo_from_format updates total_size. Add an extra data space for rockchip video
+		 * driver to store motion vectors.
+		 */
+		bo->total_size += w_mbs * h_mbs * 128;
 	} else if (width <= 2560 &&
-		   has_modifier(modifiers, count, DRM_FORMAT_MOD_CHROMEOS_ROCKCHIP_AFBC)) {
+		   drv_has_modifier(modifiers, count, DRM_FORMAT_MOD_CHROMEOS_ROCKCHIP_AFBC)) {
 		/* If the caller has decided they can use AFBC, always
 		 * pick that */
 		afbc_bo_from_format(bo, width, height, format);
 	} else {
-		if (!has_modifier(modifiers, count, DRM_FORMAT_MOD_LINEAR)) {
+		if (!drv_has_modifier(modifiers, count, DRM_FORMAT_MOD_LINEAR)) {
 			errno = EINVAL;
 			drv_log("no usable modifier found\n");
 			return -1;
@@ -214,7 +214,7 @@ static int rockchip_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint
 	if (ret) {
 		drv_log("DRM_IOCTL_ROCKCHIP_GEM_CREATE failed (size=%llu)\n",
 			(unsigned long long)gem_create.size);
-		return ret;
+		return -errno;
 	}
 
 	for (plane = 0; plane < bo->num_planes; plane++)
@@ -299,7 +299,7 @@ static int rockchip_bo_flush(struct bo *bo, struct mapping *mapping)
 	return 0;
 }
 
-static uint32_t rockchip_resolve_format(uint32_t format, uint64_t use_flags)
+static uint32_t rockchip_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
 	switch (format) {
 	case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
diff --git a/chromium/third_party/minigbm/src/tegra.c b/chromium/third_party/minigbm/src/tegra.c
index fb2f6a9cb54..4b6b8d78dcf 100644
--- a/chromium/third_party/minigbm/src/tegra.c
+++ b/chromium/third_party/minigbm/src/tegra.c
@@ -7,6 +7,7 @@
 #ifdef DRV_TEGRA
 
 #include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
@@ -229,7 +230,7 @@ static int tegra_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint3
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_TEGRA_GEM_CREATE, &gem_create);
 	if (ret) {
 		drv_log("DRM_IOCTL_TEGRA_GEM_CREATE failed (size=%zu)\n", size);
-		return ret;
+		return -errno;
 	}
 
 	bo->handles[0].u32 = gem_create.handle;
@@ -276,7 +277,7 @@ static int tegra_bo_import(struct bo *bo, struct drv_import_fd_data *data)
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_TEGRA_GEM_GET_TILING, &gem_get_tiling);
 	if (ret) {
 		drv_gem_bo_destroy(bo);
-		return ret;
+		return -errno;
 	}
 
 	/* NOTE(djmk): we only know about one tiled format, so if our drmIoctl call tells us we are
diff --git a/chromium/third_party/minigbm/src/vc4.c b/chromium/third_party/minigbm/src/vc4.c
index 71e73ea5ba0..6edd967c9cf 100644
--- a/chromium/third_party/minigbm/src/vc4.c
+++ b/chromium/third_party/minigbm/src/vc4.c
@@ -6,6 +6,7 @@
 
 #ifdef DRV_VC4
 
+#include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
@@ -49,7 +50,7 @@ static int vc4_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VC4_CREATE_BO, &bo_create);
 	if (ret) {
 		drv_log("DRM_IOCTL_VC4_GEM_CREATE failed (size=%zu)\n", bo->total_size);
-		return ret;
+		return -errno;
 	}
 
 	for (plane = 0; plane < bo->num_planes; plane++)
diff --git a/chromium/third_party/minigbm/src/vgem.c b/chromium/third_party/minigbm/src/vgem.c
index 14691d1c227..0d0371c24a0 100644
--- a/chromium/third_party/minigbm/src/vgem.c
+++ b/chromium/third_party/minigbm/src/vgem.c
@@ -38,7 +38,7 @@ static int vgem_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32
 	return drv_dumb_bo_create(bo, width, height, format, flags);
 }
 
-static uint32_t vgem_resolve_format(uint32_t format, uint64_t flags)
+static uint32_t vgem_resolve_format(struct driver *drv, uint32_t format, uint64_t flags)
 {
 	switch (format) {
 	case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
diff --git a/chromium/third_party/minigbm/src/virgl_hw.h b/chromium/third_party/minigbm/src/virgl_hw.h
index e3c56db2ac6..94e1d5ea3e1 100644
--- a/chromium/third_party/minigbm/src/virgl_hw.h
+++ b/chromium/third_party/minigbm/src/virgl_hw.h
@@ -23,6 +23,8 @@
 #ifndef VIRGL_HW_H
 #define VIRGL_HW_H
 
+#include <stdint.h>
+
 struct virgl_box {
 	uint32_t x, y, z;
 	uint32_t w, h, d;
@@ -37,6 +39,7 @@ enum virgl_formats {
    VIRGL_FORMAT_B5G5R5A1_UNORM          = 5,
    VIRGL_FORMAT_B4G4R4A4_UNORM          = 6,
    VIRGL_FORMAT_B5G6R5_UNORM            = 7,
+   VIRGL_FORMAT_R10G10B10A2_UNORM       = 8,
    VIRGL_FORMAT_L8_UNORM                = 9,    /**< ubyte luminance */
    VIRGL_FORMAT_A8_UNORM                = 10,   /**< ubyte alpha */
    VIRGL_FORMAT_L8A8_UNORM              = 12,   /**< ubyte alpha, luminance */
@@ -83,6 +86,7 @@ enum virgl_formats {
    VIRGL_FORMAT_L8A8_SRGB               = 96,
    VIRGL_FORMAT_B8G8R8A8_SRGB           = 100,
    VIRGL_FORMAT_B8G8R8X8_SRGB           = 101,
+   VIRGL_FORMAT_R8G8B8A8_SRGB           = 104,
 
    /* compressed formats */
    VIRGL_FORMAT_DXT1_RGB                = 105,
@@ -111,6 +115,8 @@ enum virgl_formats {
    VIRGL_FORMAT_B10G10R10A2_UNORM       = 131,
    VIRGL_FORMAT_R8G8B8X8_UNORM          = 134,
    VIRGL_FORMAT_B4G4R4X4_UNORM          = 135,
+   VIRGL_FORMAT_X24S8_UINT              = 136,
+   VIRGL_FORMAT_S8X24_UINT              = 137,
    VIRGL_FORMAT_B2G3R3_UNORM            = 139,
 
    VIRGL_FORMAT_L16A16_UNORM            = 140,
@@ -132,6 +138,12 @@ enum virgl_formats {
    VIRGL_FORMAT_L32_FLOAT               = 160,
    VIRGL_FORMAT_L32A32_FLOAT            = 161,
 
+   VIRGL_FORMAT_YV12                    = 163,
+   VIRGL_FORMAT_YV16                    = 164,
+   VIRGL_FORMAT_IYUV                    = 165,  /**< aka I420 */
+   VIRGL_FORMAT_NV12                    = 166,
+   VIRGL_FORMAT_NV21                    = 167,
+
    VIRGL_FORMAT_R8_UINT                 = 177,
    VIRGL_FORMAT_R8G8_UINT               = 178,
    VIRGL_FORMAT_R8G8B8_UINT             = 179,
@@ -185,17 +197,75 @@ enum virgl_formats {
    VIRGL_FORMAT_L32_SINT                = 223,
    VIRGL_FORMAT_L32A32_SINT             = 224,
 
-   VIRGL_FORMAT_B10G10R10A2_UINT        = 225, 
+   VIRGL_FORMAT_B10G10R10A2_UINT        = 225,
    VIRGL_FORMAT_R8G8B8X8_SNORM          = 229,
 
    VIRGL_FORMAT_R8G8B8X8_SRGB           = 230,
 
+   VIRGL_FORMAT_R8G8B8X8_UINT           = 231,
+   VIRGL_FORMAT_R8G8B8X8_SINT           = 232,
    VIRGL_FORMAT_B10G10R10X2_UNORM       = 233,
    VIRGL_FORMAT_R16G16B16X16_UNORM      = 234,
    VIRGL_FORMAT_R16G16B16X16_SNORM      = 235,
-   VIRGL_FORMAT_MAX,
+   VIRGL_FORMAT_R16G16B16X16_FLOAT      = 236,
+   VIRGL_FORMAT_R16G16B16X16_UINT       = 237,
+   VIRGL_FORMAT_R16G16B16X16_SINT       = 238,
+
+   VIRGL_FORMAT_R10G10B10A2_UINT        = 253,
+
+   VIRGL_FORMAT_BPTC_RGBA_UNORM         = 255,
+   VIRGL_FORMAT_BPTC_SRGBA              = 256,
+   VIRGL_FORMAT_BPTC_RGB_FLOAT          = 257,
+   VIRGL_FORMAT_BPTC_RGB_UFLOAT         = 258,
+
+   VIRGL_FORMAT_R10G10B10X2_UNORM       = 308,
+   VIRGL_FORMAT_A4B4G4R4_UNORM          = 311,
+
+   VIRGL_FORMAT_R8_SRGB                 = 312,
+   VIRGL_FORMAT_MAX /* = PIPE_FORMAT_COUNT */,
+
+   /* Below formats must not be used in the guest. */
+   VIRGL_FORMAT_B8G8R8X8_UNORM_EMULATED,
+   VIRGL_FORMAT_B8G8R8A8_UNORM_EMULATED,
+   VIRGL_FORMAT_MAX_EXTENDED
 };
 
+/* These are used by the capability_bits field in virgl_caps_v2. */
+#define VIRGL_CAP_NONE 0
+#define VIRGL_CAP_TGSI_INVARIANT       (1 << 0)
+#define VIRGL_CAP_TEXTURE_VIEW         (1 << 1)
+#define VIRGL_CAP_SET_MIN_SAMPLES      (1 << 2)
+#define VIRGL_CAP_COPY_IMAGE           (1 << 3)
+#define VIRGL_CAP_TGSI_PRECISE         (1 << 4)
+#define VIRGL_CAP_TXQS                 (1 << 5)
+#define VIRGL_CAP_MEMORY_BARRIER       (1 << 6)
+#define VIRGL_CAP_COMPUTE_SHADER       (1 << 7)
+#define VIRGL_CAP_FB_NO_ATTACH         (1 << 8)
+#define VIRGL_CAP_ROBUST_BUFFER_ACCESS (1 << 9)
+#define VIRGL_CAP_TGSI_FBFETCH         (1 << 10)
+#define VIRGL_CAP_SHADER_CLOCK         (1 << 11)
+#define VIRGL_CAP_TEXTURE_BARRIER      (1 << 12)
+#define VIRGL_CAP_TGSI_COMPONENTS      (1 << 13)
+#define VIRGL_CAP_GUEST_MAY_INIT_LOG   (1 << 14)
+#define VIRGL_CAP_SRGB_WRITE_CONTROL   (1 << 15)
+#define VIRGL_CAP_QBO                  (1 << 16)
+#define VIRGL_CAP_TRANSFER             (1 << 17)
+#define VIRGL_CAP_FBO_MIXED_COLOR_FORMATS  (1 << 18)
+#define VIRGL_CAP_FAKE_FP64            (1 << 19)
+#define VIRGL_CAP_BIND_COMMAND_ARGS    (1 << 20)
+#define VIRGL_CAP_MULTI_DRAW_INDIRECT  (1 << 21)
+#define VIRGL_CAP_INDIRECT_PARAMS      (1 << 22)
+#define VIRGL_CAP_TRANSFORM_FEEDBACK3  (1 << 23)
+#define VIRGL_CAP_3D_ASTC              (1 << 24)
+#define VIRGL_CAP_INDIRECT_INPUT_ADDR  (1 << 25)
+#define VIRGL_CAP_COPY_TRANSFER        (1 << 26)
+#define VIRGL_CAP_CLIP_HALFZ           (1 << 27)
+#define VIRGL_CAP_APP_TWEAK_SUPPORT    (1 << 28)
+#define VIRGL_CAP_BGRA_SRGB_IS_EMULATED  (1 << 29)
+
+/* virgl bind flags - these are compatible with mesa 10.5 gallium.
+ * but are fixed, no other should be passed to virgl either.
+ */
 #define VIRGL_BIND_DEPTH_STENCIL (1 << 0)
 #define VIRGL_BIND_RENDER_TARGET (1 << 1)
 #define VIRGL_BIND_SAMPLER_VIEW  (1 << 3)
@@ -203,10 +273,20 @@ enum virgl_formats {
 #define VIRGL_BIND_INDEX_BUFFER  (1 << 5)
 #define VIRGL_BIND_CONSTANT_BUFFER (1 << 6)
 #define VIRGL_BIND_DISPLAY_TARGET (1 << 7)
+#define VIRGL_BIND_COMMAND_ARGS  (1 << 8)
 #define VIRGL_BIND_STREAM_OUTPUT (1 << 11)
+#define VIRGL_BIND_SHADER_BUFFER (1 << 14)
+#define VIRGL_BIND_QUERY_BUFFER  (1 << 15)
 #define VIRGL_BIND_CURSOR        (1 << 16)
 #define VIRGL_BIND_CUSTOM        (1 << 17)
 #define VIRGL_BIND_SCANOUT       (1 << 18)
+/* Used for buffers that are backed by guest storage and
+ * are only read by the host.
+ */
+#define VIRGL_BIND_STAGING       (1 << 19)
+#define VIRGL_BIND_SHARED        (1 << 20)
+
+#define VIRGL_BIND_PREFER_EMULATED_BGRA  (1 << 21)
 
 struct virgl_caps_bool_set1 {
         unsigned indep_blend_enable:1;
@@ -232,6 +312,16 @@ struct virgl_caps_bool_set1 {
         unsigned poly_stipple:1; /* not in GL 3.1 core profile */
         unsigned mirror_clamp:1;
         unsigned texture_query_lod:1;
+        unsigned has_fp64:1;
+        unsigned has_tessellation_shaders:1;
+        unsigned has_indirect_draw:1;
+        unsigned has_sample_shading:1;
+        unsigned has_cull:1;
+        unsigned conditional_render_inverted:1;
+        unsigned derivative_control:1;
+        unsigned polygon_offset_clamp:1;
+        unsigned transform_feedback_overflow_query:1;
+        /* DO NOT ADD ANYMORE MEMBERS - need to add another 32-bit to v2 caps */
 };
 
 /* endless expansion capabilites - current gallium has 252 formats */
@@ -259,9 +349,61 @@ struct virgl_caps_v1 {
         uint32_t max_texture_gather_components;
 };
 
+/*
+ * This struct should be growable when used in capset 2,
+ * so we shouldn't have to add a v3 ever.
+ */
+struct virgl_caps_v2 {
+        struct virgl_caps_v1 v1;
+        float min_aliased_point_size;
+        float max_aliased_point_size;
+        float min_smooth_point_size;
+        float max_smooth_point_size;
+        float min_aliased_line_width;
+        float max_aliased_line_width;
+        float min_smooth_line_width;
+        float max_smooth_line_width;
+        float max_texture_lod_bias;
+        uint32_t max_geom_output_vertices;
+        uint32_t max_geom_total_output_components;
+        uint32_t max_vertex_outputs;
+        uint32_t max_vertex_attribs;
+        uint32_t max_shader_patch_varyings;
+        int32_t min_texel_offset;
+        int32_t max_texel_offset;
+        int32_t min_texture_gather_offset;
+        int32_t max_texture_gather_offset;
+        uint32_t texture_buffer_offset_alignment;
+        uint32_t uniform_buffer_offset_alignment;
+        uint32_t shader_buffer_offset_alignment;
+        uint32_t capability_bits;
+        uint32_t sample_locations[8];
+        uint32_t max_vertex_attrib_stride;
+        uint32_t max_shader_buffer_frag_compute;
+        uint32_t max_shader_buffer_other_stages;
+        uint32_t max_shader_image_frag_compute;
+        uint32_t max_shader_image_other_stages;
+        uint32_t max_image_samples;
+        uint32_t max_compute_work_group_invocations;
+        uint32_t max_compute_shared_memory_size;
+        uint32_t max_compute_grid_size[3];
+        uint32_t max_compute_block_size[3];
+        uint32_t max_texture_2d_size;
+        uint32_t max_texture_3d_size;
+        uint32_t max_texture_cube_size;
+        uint32_t max_combined_shader_buffers;
+        uint32_t max_atomic_counters[6];
+        uint32_t max_atomic_counter_buffers[6];
+        uint32_t max_combined_atomic_counters;
+        uint32_t max_combined_atomic_counter_buffers;
+        uint32_t host_feature_check_version;
+        struct virgl_supported_format_mask supported_readback_formats;
+};
+
 union virgl_caps {
         uint32_t max_version;
         struct virgl_caps_v1 v1;
+        struct virgl_caps_v2 v2;
 };
 
 enum virgl_errors {
@@ -279,8 +421,9 @@ enum virgl_ctx_errors {
         VIRGL_ERROR_CTX_ILLEGAL_SURFACE,
         VIRGL_ERROR_CTX_ILLEGAL_VERTEX_FORMAT,
         VIRGL_ERROR_CTX_ILLEGAL_CMD_BUFFER,
+        VIRGL_ERROR_CTX_GLES_HAVE_TES_BUT_MISS_TCS,
+        VIRGL_ERROR_GL_ANY_SAMPLES_PASSED,
 };
 
-
 #define VIRGL_RESOURCE_Y_0_TOP (1 << 0)
 #endif
diff --git a/chromium/third_party/minigbm/src/virtio_gpu.c b/chromium/third_party/minigbm/src/virtio_gpu.c
index 36ba8bc24ba..163207e2c21 100644
--- a/chromium/third_party/minigbm/src/virtio_gpu.c
+++ b/chromium/third_party/minigbm/src/virtio_gpu.c
@@ -30,10 +30,10 @@ static const uint32_t render_target_formats[] = { DRM_FORMAT_ABGR8888, DRM_FORMA
 						  DRM_FORMAT_XRGB8888 };
 
 static const uint32_t dumb_texture_source_formats[] = { DRM_FORMAT_R8, DRM_FORMAT_YVU420,
-							DRM_FORMAT_YVU420_ANDROID,
-							DRM_FORMAT_NV12 };
+							DRM_FORMAT_YVU420_ANDROID };
 
-static const uint32_t texture_source_formats[] = { DRM_FORMAT_R8, DRM_FORMAT_RG88 };
+static const uint32_t texture_source_formats[] = { DRM_FORMAT_NV12, DRM_FORMAT_R8, DRM_FORMAT_RG88,
+						   DRM_FORMAT_YVU420_ANDROID };
 
 struct virtio_gpu_priv {
 	int has_3d;
@@ -56,6 +56,11 @@ static uint32_t translate_format(uint32_t drm_fourcc, uint32_t plane)
 		return VIRGL_FORMAT_R8_UNORM;
 	case DRM_FORMAT_RG88:
 		return VIRGL_FORMAT_R8G8_UNORM;
+	case DRM_FORMAT_NV12:
+		return VIRGL_FORMAT_NV12;
+	case DRM_FORMAT_YVU420:
+	case DRM_FORMAT_YVU420_ANDROID:
+		return VIRGL_FORMAT_YV12;
 	default:
 		return 0;
 	}
@@ -72,6 +77,29 @@ static int virtio_dumb_bo_create(struct bo *bo, uint32_t width, uint32_t height,
 	return drv_dumb_bo_create(bo, width, height, format, use_flags);
 }
 
+static inline void handle_flag(uint64_t *flag, uint64_t check_flag, uint32_t *bind,
+			       uint32_t virgl_bind)
+{
+	if ((*flag) & check_flag) {
+		(*flag) &= ~check_flag;
+		(*bind) |= virgl_bind;
+	}
+}
+
+static uint32_t use_flags_to_bind(uint64_t use_flags)
+{
+	uint32_t bind = 0;
+
+	handle_flag(&use_flags, BO_USE_TEXTURE, &bind, VIRGL_BIND_SAMPLER_VIEW);
+	handle_flag(&use_flags, BO_USE_RENDERING, &bind, VIRGL_BIND_RENDER_TARGET);
+	handle_flag(&use_flags, BO_USE_SCANOUT, &bind, VIRGL_BIND_SCANOUT);
+	// TODO (b/12983436): handle other use flags.
+	if (use_flags) {
+		drv_log("Unhandled bo use flag: %llx\n", (unsigned long long)use_flags);
+	}
+	return bind;
+}
+
 static int virtio_virgl_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
 				  uint64_t use_flags)
 {
@@ -79,6 +107,7 @@ static int virtio_virgl_bo_create(struct bo *bo, uint32_t width, uint32_t height
 	ssize_t plane;
 	ssize_t num_planes = drv_num_planes_from_format(format);
 	uint32_t stride0;
+	uint32_t bind = use_flags_to_bind(use_flags);
 
 	for (plane = 0; plane < num_planes; plane++) {
 		uint32_t stride = drv_stride_from_format(format, width, plane);
@@ -97,7 +126,7 @@ static int virtio_virgl_bo_create(struct bo *bo, uint32_t width, uint32_t height
 		 */
 		res_create.target = PIPE_TEXTURE_2D;
 		res_create.format = res_format;
-		res_create.bind = VIRGL_BIND_RENDER_TARGET;
+		res_create.bind = bind;
 		res_create.width = width;
 		res_create.height = height;
 		res_create.depth = 1;
@@ -111,6 +140,7 @@ static int virtio_virgl_bo_create(struct bo *bo, uint32_t width, uint32_t height
 		if (ret) {
 			drv_log("DRM_IOCTL_VIRTGPU_RESOURCE_CREATE failed with %s\n",
 				strerror(errno));
+			ret = -errno;
 			goto fail;
 		}
 
@@ -174,17 +204,22 @@ static int virtio_gpu_init(struct driver *drv)
 		priv->has_3d = 0;
 	}
 
+	/* This doesn't mean host can scanout everything, it just means host
+	 * hypervisor can show it. */
 	drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-			     &LINEAR_METADATA, BO_USE_RENDER_MASK);
+			     &LINEAR_METADATA, BO_USE_RENDER_MASK | BO_USE_SCANOUT);
 
-	if (priv->has_3d)
+	if (priv->has_3d) {
 		drv_add_combinations(drv, texture_source_formats,
 				     ARRAY_SIZE(texture_source_formats), &LINEAR_METADATA,
 				     BO_USE_TEXTURE_MASK);
-	else
+	} else {
 		drv_add_combinations(drv, dumb_texture_source_formats,
 				     ARRAY_SIZE(dumb_texture_source_formats), &LINEAR_METADATA,
 				     BO_USE_TEXTURE_MASK);
+		drv_add_combination(drv, DRM_FORMAT_NV12, &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);
@@ -251,7 +286,7 @@ static int virtio_gpu_bo_invalidate(struct bo *bo, struct mapping *mapping)
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST, &xfer);
 	if (ret) {
 		drv_log("DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST failed with %s\n", strerror(errno));
-		return ret;
+		return -errno;
 	}
 
 	return 0;
@@ -280,14 +315,16 @@ static int virtio_gpu_bo_flush(struct bo *bo, struct mapping *mapping)
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST, &xfer);
 	if (ret) {
 		drv_log("DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST failed with %s\n", strerror(errno));
-		return ret;
+		return -errno;
 	}
 
 	return 0;
 }
 
-static uint32_t virtio_gpu_resolve_format(uint32_t format, uint64_t use_flags)
+static uint32_t virtio_gpu_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
+	struct virtio_gpu_priv *priv = (struct virtio_gpu_priv *)drv->priv;
+
 	switch (format) {
 	case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
 		/* Camera subsystem requires NV12. */
@@ -296,7 +333,14 @@ static uint32_t virtio_gpu_resolve_format(uint32_t format, uint64_t use_flags)
 		/*HACK: See b/28671744 */
 		return DRM_FORMAT_XBGR8888;
 	case DRM_FORMAT_FLEX_YCbCr_420_888:
-		return DRM_FORMAT_YVU420;
+		/*
+		 * All of our host drivers prefer NV12 as their flexible media format.
+		 * If that changes, this will need to be modified.
+		 */
+		if (priv->has_3d)
+			return DRM_FORMAT_NV12;
+		else
+			return DRM_FORMAT_YVU420;
 	default:
 		return format;
 	}