minigbm: rename DRV_BO_USE_* to BO_USE_*

[android-x86/external-minigbm.git] / helpers.c

diff --git a/helpers.c b/helpers.c
index 1e35936..23d17bd 100644 (file)
--- a/helpers.c
+++ b/helpers.c
@@ -11,6 +11,7 @@
 #include <string.h>
 #include <sys/mman.h>
 #include <xf86drm.h>
+#include <xf86drmMode.h>
 
 #include "drv_priv.h"
 #include "helpers.h"
@@ -274,3 +275,145 @@ uint32_t drv_log_base2(uint32_t value)
 
        return ret;
 }
+
+/* Inserts a combination into list -- caller should have lock on driver. */
+void drv_insert_supported_combination(struct driver *drv, uint32_t format,
+                                     uint64_t usage, uint64_t modifier)
+{
+       struct combination_list_element *elem;
+
+       elem = calloc(1, sizeof(*elem));
+       elem->combination.format = format;
+       elem->combination.modifier = modifier;
+       elem->combination.usage = usage;
+       LIST_ADD(&elem->link, &drv->backend->combinations);
+}
+
+void drv_insert_combinations(struct driver *drv, struct supported_combination *combos,
+                            uint32_t size)
+{
+       unsigned int i;
+
+       pthread_mutex_lock(&drv->driver_lock);
+
+       for (i = 0; i < size; i++)
+               drv_insert_supported_combination(drv, combos[i].format,
+                                                combos[i].usage,
+                                                combos[i].modifier);
+
+       pthread_mutex_unlock(&drv->driver_lock);
+}
+
+void drv_modify_supported_combination(struct driver *drv, uint32_t format,
+                                     uint64_t usage, uint64_t modifier)
+{
+       /*
+        * Attempts to add the specified usage to an existing {format, modifier}
+        * pair. If the pair is not present, a new combination is created.
+        */
+       int found = 0;
+
+       pthread_mutex_lock(&drv->driver_lock);
+
+       list_for_each_entry(struct combination_list_element,
+                           elem, &drv->backend->combinations, link) {
+               if (elem->combination.format == format &&
+                   elem->combination.modifier == modifier) {
+                       elem->combination.usage |= usage;
+                       found = 1;
+               }
+       }
+
+
+       if (!found)
+               drv_insert_supported_combination(drv, format, usage, modifier);
+
+       pthread_mutex_unlock(&drv->driver_lock);
+}
+
+int drv_add_kms_flags(struct driver *drv)
+{
+       int ret;
+       uint32_t i, j;
+       uint64_t flag, usage;
+       drmModePlanePtr plane;
+       drmModePropertyPtr prop;
+       drmModePlaneResPtr resources;
+       drmModeObjectPropertiesPtr props;
+
+       /*
+        * All current drivers can scanout XRGB8888/ARGB8888 as a primary plane.
+        * Some older kernel versions can only return overlay planes, so add the
+        * combination here. Note that the kernel disregards the alpha component
+        * of ARGB unless it's an overlay plane.
+        */
+       drv_modify_supported_combination(drv, DRM_FORMAT_XRGB8888,
+                                        BO_USE_SCANOUT, 0);
+       drv_modify_supported_combination(drv, DRM_FORMAT_ARGB8888,
+                                        BO_USE_SCANOUT, 0);
+
+       /*
+        * The ability to return universal planes is only complete on
+        * ChromeOS kernel versions >= v3.18.  The SET_CLIENT_CAP ioctl
+        * therefore might return an error code, so don't check it.  If it
+        * fails, it'll just return the plane list as overlay planes, which is
+        * fine in our case (our drivers already have cursor bits set).
+        * modetest in libdrm does the same thing.
+        */
+       drmSetClientCap(drv->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+
+       resources = drmModeGetPlaneResources(drv->fd);
+       if (!resources)
+               goto err;
+
+       for (i = 0; i < resources->count_planes; i++) {
+
+               plane = drmModeGetPlane(drv->fd, resources->planes[i]);
+
+               if (!plane)
+                       goto err;
+
+               props = drmModeObjectGetProperties(drv->fd, plane->plane_id,
+                                                  DRM_MODE_OBJECT_PLANE);
+               if (!props)
+                       goto err;
+
+               for (j = 0; j < props->count_props; j++) {
+
+                       prop = drmModeGetProperty(drv->fd, props->props[j]);
+                       if (prop) {
+                               if (strcmp(prop->name, "type") == 0) {
+                                       flag = props->prop_values[j];
+                               }
+                               drmModeFreeProperty(prop);
+                       }
+               }
+
+               switch (flag) {
+               case DRM_PLANE_TYPE_OVERLAY:
+               case DRM_PLANE_TYPE_PRIMARY:
+                       usage = BO_USE_SCANOUT;
+                       break;
+               case DRM_PLANE_TYPE_CURSOR:
+                       usage = BO_USE_CURSOR;
+                       break;
+               default:
+                       assert(0);
+               }
+
+               for (j = 0; j < plane->count_formats; j++)
+                       drv_modify_supported_combination(drv, plane->formats[j],
+                                                        usage, 0);
+
+               drmModeFreeObjectProperties(props);
+               drmModeFreePlane(plane);
+
+       }
+
+       drmModeFreePlaneResources(resources);
+       return 0;
+
+err:
+       ret = -1;
+       return ret;
+}