Merge "minui: Clean up graphics_drm.cpp." (648f252c) · Commits · e / tools / etwrp

minui/graphics_drm.cpp

+297 −351

Original line number	Diff line number	Diff line
		@@ -14,16 +14,14 @@
		* limitations under the License.
		*/

		#include <drm_fourcc.h>
		#include <fcntl.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <sys/cdefs.h>
		#include <sys/ioctl.h>
		#include <sys/mman.h>
		#include <sys/types.h>
		#include <unistd.h>

		#include <drm_fourcc.h>
		#include <xf86drm.h>
		#include <xf86drmMode.h>

		@@ -51,60 +49,54 @@ static void drm_disable_crtc(int drm_fd, drmModeCrtc *crtc) {
		drmModeSetCrtc(drm_fd, crtc->crtc_id,
		0, // fb_id
		0, 0, // x,y
		NULL, // connectors
		nullptr, // connectors
		0, // connector_count
		NULL); // mode
		nullptr); // mode
		}
		}

		static void drm_enable_crtc(int drm_fd, drmModeCrtc *crtc,
		struct drm_surface *surface) {
		int32_t ret;

		ret = drmModeSetCrtc(drm_fd, crtc->crtc_id,
		surface->fb_id,
		0, 0, // x,y
		static void drm_enable_crtc(int drm_fd, drmModeCrtc* crtc, struct drm_surface* surface) {
		int32_t ret = drmModeSetCrtc(drm_fd, crtc->crtc_id, surface->fb_id, 0, 0, // x,y
		&main_monitor_connector->connector_id,
		1, // connector_count
		&main_monitor_crtc->mode);

		if (ret)
		if (ret) {
		printf("drmModeSetCrtc failed ret=%d\n", ret);
		}
		}

		static void drm_blank(minui_backend* backend __unused, bool blank) {
		if (blank)
		if (blank) {
		drm_disable_crtc(drm_fd, main_monitor_crtc);
		else
		drm_enable_crtc(drm_fd, main_monitor_crtc,
		drm_surfaces[current_buffer]);
		} else {
		drm_enable_crtc(drm_fd, main_monitor_crtc, drm_surfaces[current_buffer]);
		}
		}

		static void drm_destroy_surface(struct drm_surface *surface) {
		struct drm_gem_close gem_close;
		int ret;

		if(!surface)
		return;
		if (!surface) return;

		if (surface->base.data)
		munmap(surface->base.data,
		surface->base.row_bytes * surface->base.height);
		if (surface->base.data) {
		munmap(surface->base.data, surface->base.row_bytes * surface->base.height);
		}

		if (surface->fb_id) {
		ret = drmModeRmFB(drm_fd, surface->fb_id);
		if (ret)
		int ret = drmModeRmFB(drm_fd, surface->fb_id);
		if (ret) {
		printf("drmModeRmFB failed ret=%d\n", ret);
		}
		}

		if (surface->handle) {
		memset(&gem_close, 0, sizeof(gem_close));
		drm_gem_close gem_close = {};
		gem_close.handle = surface->handle;

		ret = drmIoctl(drm_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
		if (ret)
		int ret = drmIoctl(drm_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
		if (ret) {
		printf("DRM_IOCTL_GEM_CLOSE failed ret=%d\n", ret);
		}
		}

		free(surface);
		}
		@@ -127,17 +119,13 @@ static int drm_format_to_bpp(uint32_t format) {
		}

		static drm_surface *drm_create_surface(int width, int height) {
		struct drm_surface *surface;
		struct drm_mode_create_dumb create_dumb;
		uint32_t format;
		int ret;

		surface = (struct drm_surface)calloc(1, sizeof(surface));
		drm_surface* surface = static_cast<drm_surface>(calloc(1, sizeof(surface)));
		if (!surface) {
		printf("Can't allocate memory\n");
		return NULL;
		return nullptr;
		}

		uint32_t format;
		#if defined(RECOVERY_ABGR)
		format = DRM_FORMAT_RGBA8888;
		#elif defined(RECOVERY_BGRA)
		@@ -148,17 +136,17 @@ static drm_surface *drm_create_surface(int width, int height) {
		format = DRM_FORMAT_RGB565;
		#endif

		memset(&create_dumb, 0, sizeof(create_dumb));
		drm_mode_create_dumb create_dumb = {};
		create_dumb.height = height;
		create_dumb.width = width;
		create_dumb.bpp = drm_format_to_bpp(format);
		create_dumb.flags = 0;

		ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
		int ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
		if (ret) {
		printf("DRM_IOCTL_MODE_CREATE_DUMB failed ret=%d\n", ret);
		drm_destroy_surface(surface);
		return NULL;
		return nullptr;
		}
		surface->handle = create_dumb.handle;

		@@ -168,75 +156,64 @@ static drm_surface *drm_create_surface(int width, int height) {
		pitches[0] = create_dumb.pitch;
		offsets[0] = 0;

		ret = drmModeAddFB2(drm_fd, width, height,
		format, handles, pitches, offsets,
		&(surface->fb_id), 0);
		ret =
		drmModeAddFB2(drm_fd, width, height, format, handles, pitches, offsets, &(surface->fb_id), 0);
		if (ret) {
		printf("drmModeAddFB2 failed ret=%d\n", ret);
		drm_destroy_surface(surface);
		return NULL;
		return nullptr;
		}

		struct drm_mode_map_dumb map_dumb;
		memset(&map_dumb, 0, sizeof(map_dumb));
		drm_mode_map_dumb map_dumb = {};
		map_dumb.handle = create_dumb.handle;
		ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);
		if (ret) {
		printf("DRM_IOCTL_MODE_MAP_DUMB failed ret=%d\n", ret);
		drm_destroy_surface(surface);
		return NULL;;
		return nullptr;
		}

		surface->base.height = height;
		surface->base.width = width;
		surface->base.row_bytes = create_dumb.pitch;
		surface->base.pixel_bytes = create_dumb.bpp / 8;
		surface->base.data = (unsigned char*)
		mmap(NULL,
		surface->base.height * surface->base.row_bytes,
		PROT_READ \| PROT_WRITE, MAP_SHARED,
		drm_fd, map_dumb.offset);
		surface->base.data =
		static_cast<unsigned char>(mmap(nullptr, surface->base.height surface->base.row_bytes,
		PROT_READ \| PROT_WRITE, MAP_SHARED, drm_fd, map_dumb.offset));
		if (surface->base.data == MAP_FAILED) {
		perror("mmap() failed");
		drm_destroy_surface(surface);
		return NULL;
		return nullptr;
		}

		return surface;
		}

		static drmModeCrtc *find_crtc_for_connector(int fd,
		drmModeRes *resources,
		static drmModeCrtc* find_crtc_for_connector(int fd, drmModeRes* resources,
		drmModeConnector* connector) {
		int i, j;
		// Find the encoder. If we already have one, just use it.
		drmModeEncoder* encoder;
		int32_t crtc;

		/*
		* Find the encoder. If we already have one, just use it.
		*/
		if (connector->encoder_id)
		if (connector->encoder_id) {
		encoder = drmModeGetEncoder(fd, connector->encoder_id);
		else
		encoder = NULL;
		} else {
		encoder = nullptr;
		}

		int32_t crtc;
		if (encoder && encoder->crtc_id) {
		crtc = encoder->crtc_id;
		drmModeFreeEncoder(encoder);
		return drmModeGetCrtc(fd, crtc);
		}

		/*
		* Didn't find anything, try to find a crtc and encoder combo.
		*/
		// Didn't find anything, try to find a crtc and encoder combo.
		crtc = -1;
		for (i = 0; i < connector->count_encoders; i++) {
		for (int i = 0; i < connector->count_encoders; i++) {
		encoder = drmModeGetEncoder(fd, connector->encoders[i]);

		if (encoder) {
		for (j = 0; j < resources->count_crtcs; j++) {
		if (!(encoder->possible_crtcs & (1 << j)))
		continue;
		for (int j = 0; j < resources->count_crtcs; j++) {
		if (!(encoder->possible_crtcs & (1 << j))) continue;
		crtc = resources->crtcs[j];
		break;
		}
		@@ -247,79 +224,64 @@ static drmModeCrtc *find_crtc_for_connector(int fd,
		}
		}

		return NULL;
		return nullptr;
		}

		static drmModeConnector *find_used_connector_by_type(int fd,
		drmModeRes *resources,
		unsigned type) {
		int i;
		for (i = 0; i < resources->count_connectors; i++) {
		drmModeConnector *connector;

		connector = drmModeGetConnector(fd, resources->connectors[i]);
		static drmModeConnector* find_used_connector_by_type(int fd, drmModeRes* resources, unsigned type) {
		for (int i = 0; i < resources->count_connectors; i++) {
		drmModeConnector* connector = drmModeGetConnector(fd, resources->connectors[i]);
		if (connector) {
		if ((connector->connector_type == type) &&
		(connector->connection == DRM_MODE_CONNECTED) &&
		(connector->count_modes > 0))
		if ((connector->connector_type == type) && (connector->connection == DRM_MODE_CONNECTED) &&
		(connector->count_modes > 0)) {
		return connector;

		}
		drmModeFreeConnector(connector);
		}
		}
		return NULL;
		return nullptr;
		}

		static drmModeConnector *find_first_connected_connector(int fd,
		drmModeRes *resources) {
		int i;
		for (i = 0; i < resources->count_connectors; i++) {
		static drmModeConnector* find_first_connected_connector(int fd, drmModeRes* resources) {
		for (int i = 0; i < resources->count_connectors; i++) {
		drmModeConnector* connector;

		connector = drmModeGetConnector(fd, resources->connectors[i]);
		if (connector) {
		if ((connector->count_modes > 0) &&
		(connector->connection == DRM_MODE_CONNECTED))
		if ((connector->count_modes > 0) && (connector->connection == DRM_MODE_CONNECTED))
		return connector;

		drmModeFreeConnector(connector);
		}
		}
		return NULL;
		return nullptr;
		}

		static drmModeConnector find_main_monitor(int fd, drmModeRes resources,
		uint32_t *mode_index) {
		unsigned i = 0;
		int modes;
		static drmModeConnector* find_main_monitor(int fd, drmModeRes* resources, uint32_t* mode_index) {
		/* Look for LVDS/eDP/DSI connectors. Those are the main screens. */
		unsigned kConnectorPriority[] = {
		static constexpr unsigned kConnectorPriority[] = {
		DRM_MODE_CONNECTOR_LVDS,
		DRM_MODE_CONNECTOR_eDP,
		DRM_MODE_CONNECTOR_DSI,
		};

		drmModeConnector *main_monitor_connector = NULL;
		drmModeConnector* main_monitor_connector = nullptr;
		unsigned i = 0;
		do {
		main_monitor_connector = find_used_connector_by_type(fd,
		resources,
		kConnectorPriority[i]);
		main_monitor_connector = find_used_connector_by_type(fd, resources, kConnectorPriority[i]);
		i++;
		} while (!main_monitor_connector && i < ARRAY_SIZE(kConnectorPriority));

		/* If we didn't find a connector, grab the first one that is connected. */
		if (!main_monitor_connector)
		main_monitor_connector =
		find_first_connected_connector(fd, resources);
		if (!main_monitor_connector) {
		main_monitor_connector = find_first_connected_connector(fd, resources);
		}

		/* If we still didn't find a connector, give up and return. */
		if (!main_monitor_connector)
		return NULL;
		if (!main_monitor_connector) return nullptr;

		*mode_index = 0;
		for (modes = 0; modes < main_monitor_connector->count_modes; modes++) {
		if (main_monitor_connector->modes[modes].type &
		DRM_MODE_TYPE_PREFERRED) {
		for (int modes = 0; modes < main_monitor_connector->count_modes; modes++) {
		if (main_monitor_connector->modes[modes].type & DRM_MODE_TYPE_PREFERRED) {
		*mode_index = modes;
		break;
		}
		@@ -328,43 +290,31 @@ static drmModeConnector find_main_monitor(int fd, drmModeRes resources,
		return main_monitor_connector;
		}

		static void disable_non_main_crtcs(int fd,
		drmModeRes *resources,
		drmModeCrtc* main_crtc) {
		int i;
		drmModeCrtc* crtc;

		for (i = 0; i < resources->count_connectors; i++) {
		drmModeConnector *connector;

		connector = drmModeGetConnector(fd, resources->connectors[i]);
		crtc = find_crtc_for_connector(fd, resources, connector);
		if (crtc->crtc_id != main_crtc->crtc_id)
		static void disable_non_main_crtcs(int fd, drmModeRes* resources, drmModeCrtc* main_crtc) {
		for (int i = 0; i < resources->count_connectors; i++) {
		drmModeConnector* connector = drmModeGetConnector(fd, resources->connectors[i]);
		drmModeCrtc* crtc = find_crtc_for_connector(fd, resources, connector);
		if (crtc->crtc_id != main_crtc->crtc_id) {
		drm_disable_crtc(fd, crtc);
		}
		drmModeFreeCrtc(crtc);
		}
		}

		static GRSurface* drm_init(minui_backend* backend __unused) {
		drmModeRes *res = NULL;
		uint32_t selected_mode;
		char *dev_name;
		int width, height;
		int ret, i;
		drmModeRes* res = nullptr;

		/* Consider DRM devices in order. */
		for (i = 0; i < DRM_MAX_MINOR; i++) {
		uint64_t cap = 0;

		ret = asprintf(&dev_name, DRM_DEV_NAME, DRM_DIR_NAME, i);
		if (ret < 0)
		continue;
		for (int i = 0; i < DRM_MAX_MINOR; i++) {
		char* dev_name;
		int ret = asprintf(&dev_name, DRM_DEV_NAME, DRM_DIR_NAME, i);
		if (ret < 0) continue;

		drm_fd = open(dev_name, O_RDWR, 0);
		free(dev_name);
		if (drm_fd < 0)
		continue;
		if (drm_fd < 0) continue;

		uint64_t cap = 0;
		/* We need dumb buffers. */
		ret = drmGetCap(drm_fd, DRM_CAP_DUMB_BUFFER, &cap);
		if (ret \|\| cap == 0) {
		@@ -379,47 +329,45 @@ static GRSurface* drm_init(minui_backend* backend __unused) {
		}

		/* Use this device if it has at least one connected monitor. */
		if (res->count_crtcs > 0 && res->count_connectors > 0)
		if (find_first_connected_connector(drm_fd, res))
		break;
		if (res->count_crtcs > 0 && res->count_connectors > 0) {
		if (find_first_connected_connector(drm_fd, res)) break;
		}

		drmModeFreeResources(res);
		close(drm_fd);
		res = NULL;
		res = nullptr;
		}

		if (drm_fd < 0 \|\| res == NULL) {
		if (drm_fd < 0 \|\| res == nullptr) {
		perror("cannot find/open a drm device");
		return NULL;
		return nullptr;
		}

		main_monitor_connector = find_main_monitor(drm_fd,
		res, &selected_mode);
		uint32_t selected_mode;
		main_monitor_connector = find_main_monitor(drm_fd, res, &selected_mode);

		if (!main_monitor_connector) {
		printf("main_monitor_connector not found\n");
		drmModeFreeResources(res);
		close(drm_fd);
		return NULL;
		return nullptr;
		}

		main_monitor_crtc = find_crtc_for_connector(drm_fd, res,
		main_monitor_connector);
		main_monitor_crtc = find_crtc_for_connector(drm_fd, res, main_monitor_connector);

		if (!main_monitor_crtc) {
		printf("main_monitor_crtc not found\n");
		drmModeFreeResources(res);
		close(drm_fd);
		return NULL;
		return nullptr;
		}

		disable_non_main_crtcs(drm_fd,
		res, main_monitor_crtc);
		disable_non_main_crtcs(drm_fd, res, main_monitor_crtc);

		main_monitor_crtc->mode = main_monitor_connector->modes[selected_mode];

		width = main_monitor_crtc->mode.hdisplay;
		height = main_monitor_crtc->mode.vdisplay;
		int width = main_monitor_crtc->mode.hdisplay;
		int height = main_monitor_crtc->mode.vdisplay;

		drmModeFreeResources(res);

		@@ -430,7 +378,7 @@ static GRSurface* drm_init(minui_backend* backend __unused) {
		drm_destroy_surface(drm_surfaces[1]);
		drmModeFreeResources(res);
		close(drm_fd);
		return NULL;
		return nullptr;
		}

		current_buffer = 0;
		@@ -441,13 +389,11 @@ static GRSurface* drm_init(minui_backend* backend __unused) {
		}

		static GRSurface* drm_flip(minui_backend* backend __unused) {
		int ret;

		ret = drmModePageFlip(drm_fd, main_monitor_crtc->crtc_id,
		drm_surfaces[current_buffer]->fb_id, 0, NULL);
		int ret = drmModePageFlip(drm_fd, main_monitor_crtc->crtc_id, drm_surfaces[current_buffer]->fb_id,
		0, nullptr);
		if (ret < 0) {
		printf("drmModePageFlip failed ret=%d\n", ret);
		return NULL;
		return nullptr;
		}
		current_buffer = 1 - current_buffer;
		return &(drm_surfaces[current_buffer]->base);