/*

 * Copyright (C) 2015 - Tobias Jakobi

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 */

#include <unistd.h>

#include <poll.h>

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <getopt.h>

#include <pthread.h>

#include <xf86drm.h>

#include "exynos_drm.h"

#include "exynos_drmif.h"

#include "exynos_fimg2d.h"

struct g2d_job {

	unsigned int id;

	unsigned int busy;

};

struct exynos_evhandler {

	struct pollfd fds;

	struct exynos_event_context evctx;

};

struct threaddata {

	unsigned int stop;

	struct exynos_device *dev;

	struct exynos_evhandler evhandler;

};

static void g2d_event_handler(int fd, unsigned int cmdlist_no, unsigned int tv_sec,

							unsigned int tv_usec, void *user_data)

{

	struct g2d_job *job = user_data;

	fprintf(stderr, "info: g2d job (id = %u, cmdlist number = %u) finished!\n",

			job->id, cmdlist_no);

	job->busy = 0;

}

static void setup_g2d_event_handler(struct exynos_evhandler *evhandler, int fd)

{

	evhandler->fds.fd = fd;

	evhandler->fds.events = POLLIN;

	evhandler->evctx.base.version = 2;

	evhandler->evctx.version = 1;

	evhandler->evctx.g2d_event_handler = g2d_event_handler;

}

static void* threadfunc(void *arg) {

	const int timeout = 0;

	struct threaddata *data;

	data = arg;

	while (1) {

		if (data->stop) break;

		usleep(500);

		data->evhandler.fds.revents = 0;

		if (poll(&data->evhandler.fds, 1, timeout) < 0)

			continue;

		if (data->evhandler.fds.revents & (POLLHUP | POLLERR))

			continue;

		if (data->evhandler.fds.revents & POLLIN)

			exynos_handle_event(data->dev, &data->evhandler.evctx);

	}

	pthread_exit(0);

}

/*

 * We need to wait until all G2D jobs are finished, otherwise we

 * potentially remove a BO which the engine still operates on.

 * This results in the following kernel message:

 * [drm:exynos_drm_gem_put_dma_addr] *ERROR* failed to lookup gem object.

 * Also any subsequent BO allocations fail then with:

 * [drm:exynos_drm_alloc_buf] *ERROR* failed to allocate buffer.

 */

static void wait_all_jobs(struct g2d_job* jobs, unsigned num_jobs)

{

	unsigned i;

	for (i = 0; i < num_jobs; ++i) {

		while (jobs[i].busy)

			usleep(500);

	}

}

static struct g2d_job* free_job(struct g2d_job* jobs, unsigned num_jobs)

{

	unsigned i;

	for (i = 0; i < num_jobs; ++i) {

		if (jobs[i].busy == 0)

			return &jobs[i];

	}

	return NULL;

}

static int g2d_work(struct g2d_context *ctx, struct g2d_image *img,

					unsigned num_jobs, unsigned iterations)

{

	struct g2d_job *jobs = calloc(num_jobs, sizeof(struct g2d_job));

	int ret;

	unsigned i;

	/* setup job ids */

	for (i = 0; i < num_jobs; ++i)

		jobs[i].id = i;

	for (i = 0; i < iterations; ++i) {

		unsigned x, y, w, h;

		struct g2d_job *j = NULL;

		while (1) {

			j = free_job(jobs, num_jobs);

			if (j)

				break;

			else

				usleep(500);

		}

		x = rand() % img->width;

		y = rand() % img->height;

		if (x == (img->width - 1))

			x -= 1;

		if (y == (img->height - 1))

			y -= 1;

		w = rand() % (img->width - x);

		h = rand() % (img->height - y);

		if (w == 0) w = 1;

		if (h == 0) h = 1;

		img->color = rand();

		j->busy = 1;

		g2d_config_event(ctx, j);

		ret = g2d_solid_fill(ctx, img, x, y, w, h);

		if (ret == 0)

			g2d_exec(ctx);

		if (ret != 0) {

			fprintf(stderr, "error: iteration %u (x = %u, x = %u, x = %u, x = %u) failed\n",

					i, x, y, w, h);

			break;

		}

	}

	wait_all_jobs(jobs, num_jobs);

	free(jobs);

	return 0;

}

static void usage(const char *name)

{

	fprintf(stderr, "usage: %s [-ijwh]\n\n", name);

	fprintf(stderr, "\t-i <number of iterations>\n");

	fprintf(stderr, "\t-j <number of G2D jobs> (default = 4)\n\n");

	fprintf(stderr, "\t-w <buffer width> (default = 4096)\n");

	fprintf(stderr, "\t-h <buffer height> (default = 4096)\n");

	exit(0);

}

int main(int argc, char **argv)

{

	int fd, ret, c, parsefail;

	pthread_t event_thread;

	struct threaddata event_data = {0};

	struct exynos_device *dev;

	struct g2d_context *ctx;

	struct exynos_bo *bo;

	struct g2d_image img = {0};

	unsigned int iters = 0, njobs = 4;

	unsigned int bufw = 4096, bufh = 4096;

	ret = 0;

	parsefail = 0;

	while ((c = getopt(argc, argv, "i:j:w:h:")) != -1) {

		switch (c) {

		case 'i':

			if (sscanf(optarg, "%u", &iters) != 1)

				parsefail = 1;

			break;

		case 'j':

			if (sscanf(optarg, "%u", &njobs) != 1)

				parsefail = 1;

			break;

		case 'w':

			if (sscanf(optarg, "%u", &bufw) != 1)

				parsefail = 1;

			break;

		case 'h':

			if (sscanf(optarg, "%u", &bufh) != 1)

				parsefail = 1;

			break;

		default:

			parsefail = 1;

			break;

		}

	}

	if (parsefail || (argc == 1) || (iters == 0))

		usage(argv[0]);

	if (bufw > 4096 || bufh > 4096) {

		fprintf(stderr, "error: buffer width/height should be less than 4096.\n");

		ret = -1;

		goto out;

	}

	if (bufw == 0 || bufh == 0) {

		fprintf(stderr, "error: buffer width/height should be non-zero.\n");

		ret = -1;

		goto out;

	}

	fd = drmOpen("exynos", NULL);

	if (fd < 0) {

		fprintf(stderr, "error: failed to open drm\n");

		ret = -1;

		goto out;

	}

	dev = exynos_device_create(fd);

	if (dev == NULL) {

		fprintf(stderr, "error: failed to create device\n");

		ret = -2;

		goto fail;

	}

	ctx = g2d_init(fd);

	if (ctx == NULL) {

		fprintf(stderr, "error: failed to init G2D\n");

		ret = -3;

		goto g2d_fail;

	}

	bo = exynos_bo_create(dev, bufw * bufh * 4, 0);

	if (bo == NULL) {

		fprintf(stderr, "error: failed to create bo\n");

		ret = -4;

		goto bo_fail;

	}

	/* setup g2d image object */

	img.width = bufw;

	img.height = bufh;

	img.stride = bufw * 4;

	img.color_mode = G2D_COLOR_FMT_ARGB8888 | G2D_ORDER_AXRGB;

	img.buf_type = G2D_IMGBUF_GEM;

	img.bo[0] = bo->handle;

	event_data.dev = dev;

	setup_g2d_event_handler(&event_data.evhandler, fd);

	pthread_create(&event_thread, NULL, threadfunc, &event_data);

	ret = g2d_work(ctx, &img, njobs, iters);

	if (ret != 0)

		fprintf(stderr, "error: g2d_work failed\n");

	event_data.stop = 1;

	pthread_join(event_thread, NULL);

	exynos_bo_destroy(bo);

bo_fail:

	g2d_fini(ctx);

g2d_fail:

	exynos_device_destroy(dev);

fail:

	drmClose(fd);

out:

	return ret;

}