/*
 * Copyright (C) 2016 Philippe Gerum <rpm@xenomai.org>
 *
 * 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 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 THE AUTHORS OR COPYRIGHT HOLDERS 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 <stdio.h>
#include <error.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <smokey/smokey.h>
#include <rtdm/gpio.h>
#include <boilerplate/time.h>

smokey_test_plugin(interrupt,
		   SMOKEY_ARGLIST(
			   SMOKEY_STRING(device),
			   SMOKEY_STRING(trigger),
			   SMOKEY_BOOL(select),
			   SMOKEY_BOOL(timestamp),
		   ),
   "Wait for interrupts from a GPIO pin.\n"
   "\tdevice=<device-path>\n"
   "\trigger={edge[-rising/falling/both], level[-low/high]}\n"
   "\tselect, wait on select(2)."
   "\ttimestamp, enable timestamping."
);

smokey_test_plugin(read_value,
		   SMOKEY_ARGLIST(
			   SMOKEY_STRING(device),
		   ),
   "Read GPIO value.\n"
   "\tdevice=<device-path>."
);

smokey_test_plugin(write_value,
		   SMOKEY_ARGLIST(
			   SMOKEY_STRING(device),
		   ),
   "Write GPIO value.\n"
   "\tdevice=<device-path>."
);

static int run_interrupt(struct smokey_test *t, int argc, char *const argv[])
{
	static struct {
		const char *name;
		int flag;
	} trigger_types[] = {
		{ .name = "edge", .flag = GPIO_TRIGGER_EDGE_RISING },
		{ .name = "edge-rising", .flag = GPIO_TRIGGER_EDGE_RISING },
		{ .name = "edge-falling", .flag = GPIO_TRIGGER_EDGE_FALLING },
		{ .name = "edge-both", .flag = GPIO_TRIGGER_EDGE_FALLING|GPIO_TRIGGER_EDGE_RISING },
		{ .name = "level", .flag = GPIO_TRIGGER_LEVEL_LOW },
		{ .name = "level-low", .flag = GPIO_TRIGGER_LEVEL_LOW },
		{ .name = "level-high", .flag = GPIO_TRIGGER_LEVEL_HIGH },
		{ NULL, 0 },
	};
	int do_select = 0, fd, ret, trigger, n, value, do_timestamp = 0;
	const char *device = NULL, *trigname;
	struct rtdm_gpio_readout rdo;
	struct timespec now;
	fd_set set;
	
	smokey_parse_args(t, argc, argv);

	if (!SMOKEY_ARG_ISSET(interrupt, device)) {
		warning("missing device= specification");
		return -EINVAL;
	}

	device = SMOKEY_ARG_STRING(interrupt, device);
	fd = open(device, O_RDWR);
	if (fd < 0) {
		ret = -errno;
		warning("cannot open device %s [%s]",
			device, symerror(ret));
		return ret;
	}

	if (SMOKEY_ARG_ISSET(interrupt, select))
		do_select = SMOKEY_ARG_BOOL(interrupt, select);

	if (SMOKEY_ARG_ISSET(interrupt, timestamp))
		do_timestamp = SMOKEY_ARG_BOOL(interrupt, timestamp);

	trigger = GPIO_TRIGGER_NONE;
	if (SMOKEY_ARG_ISSET(interrupt, trigger)) {
		trigname = SMOKEY_ARG_STRING(interrupt, trigger);
		for (n = 0; trigger_types[n].name; n++) {
			if (strcmp(trigger_types[n].name, trigname) == 0) {
				trigger = trigger_types[n].flag;
				break;
		    }
		}
		if (trigger == GPIO_TRIGGER_NONE) {
			warning("invalid trigger type %s", trigname);
			return -EINVAL;
		}
	}

	ret = ioctl(fd, GPIO_RTIOC_IRQEN, &trigger);
	if (ret) {
		ret = -errno;
		warning("GPIO_RTIOC_IRQEN failed on %s [%s]",
			device, symerror(ret));
		return ret;
	}

	FD_ZERO(&set);
	FD_SET(fd, &set);
	
	for (;;) {
		if (do_select) {
			ret = select(fd + 1, &set, NULL, NULL, NULL);
			if (ret < 0) {
				ret = -errno;
				warning("failed listening to %s [%s]",
					device, symerror(ret));
				return ret;
			}
		}
		if (do_timestamp) {
			ret = read(fd, &rdo, sizeof(rdo));
			if (ret < 0) {
				ret = -errno;
				warning("failed reading from %s [%s]",
					device, symerror(ret));
				return ret;
			}
			clock_gettime(CLOCK_MONOTONIC, &now);
			printf("received irq %llu us from now, GPIO state=%d\n",
			       (timespec_scalar(&now) - rdo.timestamp) / 1000ULL,
			       rdo.value);
		} else {
			ret = read(fd, &value, sizeof(value));
			if (ret < 0) {
				ret = -errno;
				warning("failed reading from %s [%s]",
					device, symerror(ret));
				return ret;
			}
			printf("received irq, GPIO state=%d\n", value);
		}
	}

	close(fd);

	return 0;
}

static int run_read_value(struct smokey_test *t, int argc, char *const argv[])
{
	const char *device = NULL;
	int fd, ret, value = -1;

	smokey_parse_args(t, argc, argv);

	if (!SMOKEY_ARG_ISSET(read_value, device)) {
		warning("missing device= specification");
		return -EINVAL;
	}

	device = SMOKEY_ARG_STRING(read_value, device);
	fd = open(device, O_RDONLY|O_NONBLOCK);
	if (fd < 0) {
		ret = -errno;
		warning("cannot open device %s [%s]",
			device, symerror(ret));
		return ret;
	}

	if (!__Terrno(ret, ioctl(fd, GPIO_RTIOC_DIR_IN)))
		return ret;

	ret = read(fd, &value, sizeof(value));
	close(fd);

	if (!__Tassert(ret == sizeof(value)))
		return -EINVAL;

	smokey_trace("value=%d", value);

	return 0;
}

static int run_write_value(struct smokey_test *t, int argc, char *const argv[])
{
	const char *device = NULL;
	int fd, ret, value;
	
	smokey_parse_args(t, argc, argv);

	if (!SMOKEY_ARG_ISSET(write_value, device)) {
		warning("missing device= specification");
		return -EINVAL;
	}

	device = SMOKEY_ARG_STRING(write_value, device);
	fd = open(device, O_WRONLY);
	if (fd < 0) {
		ret = -errno;
		warning("cannot open device %s [%s]",
			device, symerror(ret));
		return ret;
	}

	value = 1;
	if (!__Terrno(ret, ioctl(fd, GPIO_RTIOC_DIR_OUT, &value)))
		return ret;
	
	ret = write(fd, &value, sizeof(value));
	close(fd);

	if (!__Tassert(ret == sizeof(value)))
		return -EINVAL;

	return 0;
}

int main(int argc, char *const argv[])
{
	struct smokey_test *t;
	int ret, fails = 0;

	if (pvlist_empty(&smokey_test_list))
		return 0;

	for_each_smokey_test(t) {
		ret = t->run(t, argc, argv);
		if (ret) {
			if (ret == -ENOSYS) {
				smokey_note("%s skipped (no kernel support)",
					    t->name);
				continue;
			}
			fails++;
			if (smokey_keep_going)
				continue;
			if (smokey_verbose_mode)
				error(1, -ret, "test %s failed", t->name);
			return 1;
		}
		smokey_note("%s OK", t->name);
	}

	return fails != 0;
}