summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--minui/graphics_adf.cpp347
1 files changed, 156 insertions, 191 deletions
diff --git a/minui/graphics_adf.cpp b/minui/graphics_adf.cpp
index 9e262b044..17f30d1d4 100644
--- a/minui/graphics_adf.cpp
+++ b/minui/graphics_adf.cpp
@@ -16,14 +16,10 @@
#include <errno.h>
#include <fcntl.h>
-#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <sys/cdefs.h>
#include <sys/mman.h>
+#include <unistd.h>
#include <adf/adf.h>
#include <sync/sync.h>
@@ -31,243 +27,212 @@
#include "graphics.h"
struct adf_surface_pdata {
- GRSurface base;
- int fence_fd;
- int fd;
- __u32 offset;
- __u32 pitch;
+ GRSurface base;
+ int fence_fd;
+ int fd;
+ __u32 offset;
+ __u32 pitch;
};
struct adf_pdata {
- minui_backend base;
- int intf_fd;
- adf_id_t eng_id;
- __u32 format;
+ minui_backend base;
+ int intf_fd;
+ adf_id_t eng_id;
+ __u32 format;
- adf_device dev;
+ adf_device dev;
- unsigned int current_surface;
- unsigned int n_surfaces;
- adf_surface_pdata surfaces[2];
+ unsigned int current_surface;
+ unsigned int n_surfaces;
+ adf_surface_pdata surfaces[2];
};
-static GRSurface* adf_flip(minui_backend *backend);
-static void adf_blank(minui_backend *backend, bool blank);
-
-static int adf_surface_init(adf_pdata *pdata, drm_mode_modeinfo *mode, adf_surface_pdata *surf) {
- memset(surf, 0, sizeof(*surf));
-
- surf->fence_fd = -1;
- surf->fd = adf_interface_simple_buffer_alloc(pdata->intf_fd, mode->hdisplay,
- mode->vdisplay, pdata->format, &surf->offset, &surf->pitch);
- if (surf->fd < 0)
- return surf->fd;
-
- surf->base.width = mode->hdisplay;
- surf->base.height = mode->vdisplay;
- surf->base.row_bytes = surf->pitch;
- surf->base.pixel_bytes = (pdata->format == DRM_FORMAT_RGB565) ? 2 : 4;
-
- surf->base.data = static_cast<uint8_t*>(mmap(NULL,
- surf->pitch * surf->base.height, PROT_WRITE,
- MAP_SHARED, surf->fd, surf->offset));
- if (surf->base.data == MAP_FAILED) {
- close(surf->fd);
- return -errno;
- }
+static GRSurface* adf_flip(minui_backend* backend);
+static void adf_blank(minui_backend* backend, bool blank);
+
+static int adf_surface_init(adf_pdata* pdata, drm_mode_modeinfo* mode, adf_surface_pdata* surf) {
+ *surf = {};
+ surf->fence_fd = -1;
+ surf->fd = adf_interface_simple_buffer_alloc(pdata->intf_fd, mode->hdisplay, mode->vdisplay,
+ pdata->format, &surf->offset, &surf->pitch);
+ if (surf->fd < 0) {
+ return surf->fd;
+ }
+
+ surf->base.width = mode->hdisplay;
+ surf->base.height = mode->vdisplay;
+ surf->base.row_bytes = surf->pitch;
+ surf->base.pixel_bytes = (pdata->format == DRM_FORMAT_RGB565) ? 2 : 4;
+
+ surf->base.data = static_cast<uint8_t*>(mmap(nullptr, surf->pitch * surf->base.height, PROT_WRITE,
+ MAP_SHARED, surf->fd, surf->offset));
+ if (surf->base.data == MAP_FAILED) {
+ close(surf->fd);
+ return -errno;
+ }
- return 0;
+ return 0;
}
-static int adf_interface_init(adf_pdata *pdata)
-{
- adf_interface_data intf_data;
- int ret = 0;
- int err;
-
- err = adf_get_interface_data(pdata->intf_fd, &intf_data);
- if (err < 0)
- return err;
-
- err = adf_surface_init(pdata, &intf_data.current_mode, &pdata->surfaces[0]);
- if (err < 0) {
- fprintf(stderr, "allocating surface 0 failed: %s\n", strerror(-err));
- ret = err;
- goto done;
- }
-
- err = adf_surface_init(pdata, &intf_data.current_mode,
- &pdata->surfaces[1]);
- if (err < 0) {
- fprintf(stderr, "allocating surface 1 failed: %s\n", strerror(-err));
- memset(&pdata->surfaces[1], 0, sizeof(pdata->surfaces[1]));
- pdata->n_surfaces = 1;
- } else {
- pdata->n_surfaces = 2;
- }
+static int adf_interface_init(adf_pdata* pdata) {
+ adf_interface_data intf_data;
+ int err = adf_get_interface_data(pdata->intf_fd, &intf_data);
+ if (err < 0) return err;
+
+ int ret = 0;
+ err = adf_surface_init(pdata, &intf_data.current_mode, &pdata->surfaces[0]);
+ if (err < 0) {
+ fprintf(stderr, "allocating surface 0 failed: %s\n", strerror(-err));
+ ret = err;
+ goto done;
+ }
+
+ err = adf_surface_init(pdata, &intf_data.current_mode, &pdata->surfaces[1]);
+ if (err < 0) {
+ fprintf(stderr, "allocating surface 1 failed: %s\n", strerror(-err));
+ pdata->surfaces[1] = {};
+ pdata->n_surfaces = 1;
+ } else {
+ pdata->n_surfaces = 2;
+ }
done:
- adf_free_interface_data(&intf_data);
- return ret;
+ adf_free_interface_data(&intf_data);
+ return ret;
}
-static int adf_device_init(adf_pdata *pdata, adf_device *dev)
-{
- adf_id_t intf_id;
- int intf_fd;
- int err;
+static int adf_device_init(adf_pdata* pdata, adf_device* dev) {
+ adf_id_t intf_id;
+ int err = adf_find_simple_post_configuration(dev, &pdata->format, 1, &intf_id, &pdata->eng_id);
+ if (err < 0) return err;
- err = adf_find_simple_post_configuration(dev, &pdata->format, 1, &intf_id,
- &pdata->eng_id);
- if (err < 0)
- return err;
+ err = adf_device_attach(dev, pdata->eng_id, intf_id);
+ if (err < 0 && err != -EALREADY) return err;
- err = adf_device_attach(dev, pdata->eng_id, intf_id);
- if (err < 0 && err != -EALREADY)
- return err;
+ pdata->intf_fd = adf_interface_open(dev, intf_id, O_RDWR);
+ if (pdata->intf_fd < 0) return pdata->intf_fd;
- pdata->intf_fd = adf_interface_open(dev, intf_id, O_RDWR);
- if (pdata->intf_fd < 0)
- return pdata->intf_fd;
-
- err = adf_interface_init(pdata);
- if (err < 0) {
- close(pdata->intf_fd);
- pdata->intf_fd = -1;
- }
+ err = adf_interface_init(pdata);
+ if (err < 0) {
+ close(pdata->intf_fd);
+ pdata->intf_fd = -1;
+ }
- return err;
+ return err;
}
-static GRSurface* adf_init(minui_backend *backend)
-{
- adf_pdata *pdata = (adf_pdata *)backend;
- adf_id_t *dev_ids = NULL;
- ssize_t n_dev_ids, i;
- GRSurface* ret;
+static GRSurface* adf_init(minui_backend* backend) {
+ adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);
#if defined(RECOVERY_ABGR)
- pdata->format = DRM_FORMAT_ABGR8888;
+ pdata->format = DRM_FORMAT_ABGR8888;
#elif defined(RECOVERY_BGRA)
- pdata->format = DRM_FORMAT_BGRA8888;
+ pdata->format = DRM_FORMAT_BGRA8888;
#elif defined(RECOVERY_RGBX)
- pdata->format = DRM_FORMAT_RGBX8888;
+ pdata->format = DRM_FORMAT_RGBX8888;
#else
- pdata->format = DRM_FORMAT_RGB565;
+ pdata->format = DRM_FORMAT_RGB565;
#endif
- n_dev_ids = adf_devices(&dev_ids);
- if (n_dev_ids == 0) {
- return NULL;
- } else if (n_dev_ids < 0) {
- fprintf(stderr, "enumerating adf devices failed: %s\n",
- strerror(-n_dev_ids));
- return NULL;
- }
+ adf_id_t* dev_ids = nullptr;
+ ssize_t n_dev_ids = adf_devices(&dev_ids);
+ if (n_dev_ids == 0) {
+ return nullptr;
+ } else if (n_dev_ids < 0) {
+ fprintf(stderr, "enumerating adf devices failed: %s\n", strerror(-n_dev_ids));
+ return nullptr;
+ }
- pdata->intf_fd = -1;
+ pdata->intf_fd = -1;
- for (i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {
-
- int err = adf_device_open(dev_ids[i], O_RDWR, &pdata->dev);
- if (err < 0) {
- fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i],
- strerror(-err));
- continue;
- }
-
- err = adf_device_init(pdata, &pdata->dev);
- if (err < 0) {
- fprintf(stderr, "initializing adf device %u failed: %s\n",
- dev_ids[i], strerror(-err));
- adf_device_close(&pdata->dev);
- }
+ for (ssize_t i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {
+ int err = adf_device_open(dev_ids[i], O_RDWR, &pdata->dev);
+ if (err < 0) {
+ fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i], strerror(-err));
+ continue;
}
- free(dev_ids);
+ err = adf_device_init(pdata, &pdata->dev);
+ if (err < 0) {
+ fprintf(stderr, "initializing adf device %u failed: %s\n", dev_ids[i], strerror(-err));
+ adf_device_close(&pdata->dev);
+ }
+ }
- if (pdata->intf_fd < 0)
- return NULL;
+ free(dev_ids);
- ret = adf_flip(backend);
+ if (pdata->intf_fd < 0) return nullptr;
- adf_blank(backend, true);
- adf_blank(backend, false);
+ GRSurface* ret = adf_flip(backend);
- return ret;
-}
+ adf_blank(backend, true);
+ adf_blank(backend, false);
-static void adf_sync(adf_surface_pdata *surf)
-{
- unsigned int warningTimeout = 3000;
+ return ret;
+}
- if (surf == NULL)
- return;
+static void adf_sync(adf_surface_pdata* surf) {
+ static constexpr unsigned int warningTimeout = 3000;
- if (surf->fence_fd >= 0){
- int err = sync_wait(surf->fence_fd, warningTimeout);
- if (err < 0)
- perror("adf sync fence wait error\n");
+ if (surf == nullptr) return;
- close(surf->fence_fd);
- surf->fence_fd = -1;
+ if (surf->fence_fd >= 0) {
+ int err = sync_wait(surf->fence_fd, warningTimeout);
+ if (err < 0) {
+ perror("adf sync fence wait error\n");
}
+
+ close(surf->fence_fd);
+ surf->fence_fd = -1;
+ }
}
-static GRSurface* adf_flip(minui_backend *backend)
-{
- adf_pdata *pdata = (adf_pdata *)backend;
- adf_surface_pdata *surf = &pdata->surfaces[pdata->current_surface];
+static GRSurface* adf_flip(minui_backend* backend) {
+ adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);
+ adf_surface_pdata* surf = &pdata->surfaces[pdata->current_surface];
- int fence_fd = adf_interface_simple_post(pdata->intf_fd, pdata->eng_id,
- surf->base.width, surf->base.height, pdata->format, surf->fd,
- surf->offset, surf->pitch, -1);
- if (fence_fd >= 0)
- surf->fence_fd = fence_fd;
+ int fence_fd =
+ adf_interface_simple_post(pdata->intf_fd, pdata->eng_id, surf->base.width, surf->base.height,
+ pdata->format, surf->fd, surf->offset, surf->pitch, -1);
+ if (fence_fd >= 0) surf->fence_fd = fence_fd;
- pdata->current_surface = (pdata->current_surface + 1) % pdata->n_surfaces;
- adf_sync(&pdata->surfaces[pdata->current_surface]);
- return &pdata->surfaces[pdata->current_surface].base;
+ pdata->current_surface = (pdata->current_surface + 1) % pdata->n_surfaces;
+ adf_sync(&pdata->surfaces[pdata->current_surface]);
+ return &pdata->surfaces[pdata->current_surface].base;
}
-static void adf_blank(minui_backend *backend, bool blank)
-{
- adf_pdata *pdata = (adf_pdata *)backend;
- adf_interface_blank(pdata->intf_fd,
- blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
+static void adf_blank(minui_backend* backend, bool blank) {
+ adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);
+ adf_interface_blank(pdata->intf_fd, blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
}
-static void adf_surface_destroy(adf_surface_pdata *surf)
-{
- munmap(surf->base.data, surf->pitch * surf->base.height);
- close(surf->fence_fd);
- close(surf->fd);
+static void adf_surface_destroy(adf_surface_pdata* surf) {
+ munmap(surf->base.data, surf->pitch * surf->base.height);
+ close(surf->fence_fd);
+ close(surf->fd);
}
-static void adf_exit(minui_backend *backend)
-{
- adf_pdata *pdata = (adf_pdata *)backend;
- unsigned int i;
-
- adf_device_close(&pdata->dev);
- for (i = 0; i < pdata->n_surfaces; i++)
- adf_surface_destroy(&pdata->surfaces[i]);
- if (pdata->intf_fd >= 0)
- close(pdata->intf_fd);
- free(pdata);
+static void adf_exit(minui_backend* backend) {
+ adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);
+ adf_device_close(&pdata->dev);
+ for (unsigned int i = 0; i < pdata->n_surfaces; i++) {
+ adf_surface_destroy(&pdata->surfaces[i]);
+ }
+ if (pdata->intf_fd >= 0) close(pdata->intf_fd);
+ free(pdata);
}
-minui_backend *open_adf()
-{
- adf_pdata* pdata = static_cast<adf_pdata*>(calloc(1, sizeof(*pdata)));
- if (!pdata) {
- perror("allocating adf backend failed");
- return NULL;
- }
+minui_backend* open_adf() {
+ adf_pdata* pdata = static_cast<adf_pdata*>(calloc(1, sizeof(*pdata)));
+ if (!pdata) {
+ perror("allocating adf backend failed");
+ return nullptr;
+ }
+
+ pdata->base.init = adf_init;
+ pdata->base.flip = adf_flip;
+ pdata->base.blank = adf_blank;
+ pdata->base.exit = adf_exit;
- pdata->base.init = adf_init;
- pdata->base.flip = adf_flip;
- pdata->base.blank = adf_blank;
- pdata->base.exit = adf_exit;
- return &pdata->base;
+ return &pdata->base;
}