Merge "minui: Clean up graphics_adf.cpp." (d592e1d5) · Commits · e / tools / etwrp

minui/graphics_adf.cpp

+156 −191

Original line number	Diff line number	Diff line
		@@ -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>
		@@ -55,21 +51,20 @@ 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 = {};
		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)
		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,
		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);
		@@ -79,16 +74,12 @@ static int adf_surface_init(adf_pdata pdata, drm_mode_modeinfo mode, adf_surfa
		return 0;
		}

		static int adf_interface_init(adf_pdata *pdata)
		{
		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;
		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));
		@@ -96,11 +87,10 @@ static int adf_interface_init(adf_pdata *pdata)
		goto done;
		}

		err = adf_surface_init(pdata, &intf_data.current_mode,
		&pdata->surfaces[1]);
		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->surfaces[1] = {};
		pdata->n_surfaces = 1;
		} else {
		pdata->n_surfaces = 2;
		@@ -111,24 +101,16 @@ done:
		return ret;
		}

		static int adf_device_init(adf_pdata pdata, adf_device dev)
		{
		static int adf_device_init(adf_pdata* pdata, adf_device* dev) {
		adf_id_t intf_id;
		int intf_fd;
		int err;

		err = adf_find_simple_post_configuration(dev, &pdata->format, 1, &intf_id,
		&pdata->eng_id);
		if (err < 0)
		return err;
		int 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;
		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;
		if (pdata->intf_fd < 0) return pdata->intf_fd;

		err = adf_interface_init(pdata);
		if (err < 0) {
		@@ -139,12 +121,8 @@ static int adf_device_init(adf_pdata pdata, adf_device dev)
		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;
		@@ -156,40 +134,36 @@ static GRSurface* adf_init(minui_backend *backend)
		pdata->format = DRM_FORMAT_RGB565;
		#endif

		n_dev_ids = adf_devices(&dev_ids);
		adf_id_t* dev_ids = nullptr;
		ssize_t n_dev_ids = adf_devices(&dev_ids);
		if (n_dev_ids == 0) {
		return NULL;
		return nullptr;
		} else if (n_dev_ids < 0) {
		fprintf(stderr, "enumerating adf devices failed: %s\n",
		strerror(-n_dev_ids));
		return NULL;
		fprintf(stderr, "enumerating adf devices failed: %s\n", strerror(-n_dev_ids));
		return nullptr;
		}

		pdata->intf_fd = -1;

		for (i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {

		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));
		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));
		fprintf(stderr, "initializing adf device %u failed: %s\n", dev_ids[i], strerror(-err));
		adf_device_close(&pdata->dev);
		}
		}

		free(dev_ids);

		if (pdata->intf_fd < 0)
		return NULL;
		if (pdata->intf_fd < 0) return nullptr;

		ret = adf_flip(backend);
		GRSurface* ret = adf_flip(backend);

		adf_blank(backend, true);
		adf_blank(backend, false);
		@@ -197,77 +171,68 @@ static GRSurface* adf_init(minui_backend *backend)
		return ret;
		}

		static void adf_sync(adf_surface_pdata *surf)
		{
		unsigned int warningTimeout = 3000;
		static void adf_sync(adf_surface_pdata* surf) {
		static constexpr unsigned int warningTimeout = 3000;

		if (surf == NULL)
		return;
		if (surf == nullptr) return;

		if (surf->fence_fd >= 0) {
		int err = sync_wait(surf->fence_fd, warningTimeout);
		if (err < 0)
		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;
		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;
		}

		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)
		{
		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;

		static void adf_exit(minui_backend* backend) {
		adf_pdata* pdata = reinterpret_cast<adf_pdata*>(backend);
		adf_device_close(&pdata->dev);
		for (i = 0; i < pdata->n_surfaces; i++)
		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);
		}
		if (pdata->intf_fd >= 0) close(pdata->intf_fd);
		free(pdata);
		}

		minui_backend *open_adf()
		{
		minui_backend* open_adf() {
		adf_pdata* pdata = static_cast<adf_pdata>(calloc(1, sizeof(pdata)));
		if (!pdata) {
		perror("allocating adf backend failed");
		return NULL;
		return nullptr;
		}

		pdata->base.init = adf_init;
		pdata->base.flip = adf_flip;
		pdata->base.blank = adf_blank;
		pdata->base.exit = adf_exit;

		return &pdata->base;
		}