/**
 * @note Copyright (C) 2016 Philippe Gerum <rpm@xenomai.org>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/gpio.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <rtdm/gpio.h>

struct rtdm_gpio_chan {
	int requested : 1,
		has_direction : 1,
		is_output : 1,
	        is_interrupt : 1,
		want_timestamp : 1;
};

static LIST_HEAD(rtdm_gpio_chips);

static DEFINE_MUTEX(chip_lock);

static int gpio_pin_interrupt(rtdm_irq_t *irqh)
{
	struct rtdm_gpio_pin *pin;

	pin = rtdm_irq_get_arg(irqh, struct rtdm_gpio_pin);

	if (pin->monotonic_timestamp)
		pin->timestamp = rtdm_clock_read_monotonic();
	else
		pin->timestamp = rtdm_clock_read();
	rtdm_event_signal(&pin->event);

	return RTDM_IRQ_HANDLED;
}

static int request_gpio_irq(unsigned int gpio, struct rtdm_gpio_pin *pin,
			    struct rtdm_gpio_chan *chan,
			    int trigger)
{
	int ret, irq_trigger, irq;

	if (trigger & ~GPIO_TRIGGER_MASK)
		return -EINVAL;

	if (!chan->requested) {
		ret = gpio_request(gpio, pin->name);
		if (ret) {
			if (ret != -EPROBE_DEFER)
				printk(XENO_ERR 
				       "can not request GPIO%d\n", gpio);
			return ret;
		}
		chan->requested = true;
	}

	ret = gpio_direction_input(gpio);
	if (ret) {
		printk(XENO_ERR "cannot set GPIO%d as input\n", gpio);
		goto fail;
	}

	chan->has_direction = true;
	gpio_export(gpio, true);

	rtdm_event_clear(&pin->event);

	/*
	 * Attempt to hook the interrupt associated to that pin. We
	 * might fail getting a valid IRQ number, in case the GPIO
	 * chip did not define any mapping handler (->to_irq). If so,
	 * just assume that either we have no IRQ indeed, or interrupt
	 * handling may be open coded elsewhere.
	 */
	irq = gpio_to_irq(gpio);
	if (irq < 0)
		goto done;

	irq_trigger = 0;
	if (trigger & GPIO_TRIGGER_EDGE_RISING)
		irq_trigger |= IRQ_TYPE_EDGE_RISING;
	if (trigger & GPIO_TRIGGER_EDGE_FALLING)
		irq_trigger |= IRQ_TYPE_EDGE_FALLING;
	if (trigger & GPIO_TRIGGER_LEVEL_HIGH)
		irq_trigger |= IRQ_TYPE_LEVEL_HIGH;
	if (trigger & GPIO_TRIGGER_LEVEL_LOW)
		irq_trigger |= IRQ_TYPE_LEVEL_LOW;

	if (irq_trigger)
		irq_set_irq_type(irq, irq_trigger);
	
	ret = rtdm_irq_request(&pin->irqh, irq, gpio_pin_interrupt,
			       0, pin->name, pin);
	if (ret) {
		printk(XENO_ERR "cannot request GPIO%d interrupt\n", gpio);
		goto fail;
	}


	rtdm_irq_enable(&pin->irqh);
done:
	chan->is_interrupt = true;

	return 0;
fail:
	gpio_free(gpio);
	chan->requested = false;

	return ret;
}

static void release_gpio_irq(unsigned int gpio, struct rtdm_gpio_pin *pin,
			     struct rtdm_gpio_chan *chan)
{
	if (chan->is_interrupt) {
		rtdm_irq_free(&pin->irqh);
		chan->is_interrupt = false;
	}
	gpio_free(gpio);
	chan->requested = false;
}

static int gpio_pin_ioctl_nrt(struct rtdm_fd *fd,
			      unsigned int request, void *arg)
{
	struct rtdm_gpio_chan *chan = rtdm_fd_to_private(fd);
	struct rtdm_device *dev = rtdm_fd_device(fd);
	unsigned int gpio = rtdm_fd_minor(fd);
	int ret = 0, val, trigger;
	struct rtdm_gpio_pin *pin;
	
	pin = container_of(dev, struct rtdm_gpio_pin, dev);

	switch (request) {
	case GPIO_RTIOC_DIR_OUT:
		ret = rtdm_safe_copy_from_user(fd, &val, arg, sizeof(val));
		if (ret)
			return ret;
		ret = gpio_direction_output(gpio, val);
		if (ret == 0) {
			chan->has_direction = true;
			chan->is_output = true;
		}
		break;
	case GPIO_RTIOC_DIR_IN:
		ret = gpio_direction_input(gpio);
		if (ret == 0)
			chan->has_direction = true;
		break;
	case GPIO_RTIOC_IRQEN:
		if (chan->is_interrupt) {
			return -EBUSY;
		}
		ret = rtdm_safe_copy_from_user(fd, &trigger,
					       arg, sizeof(trigger));
		if (ret)
			return ret;
		ret = request_gpio_irq(gpio, pin, chan, trigger);
		break;
	case GPIO_RTIOC_IRQDIS:
		if (chan->is_interrupt) {
			release_gpio_irq(gpio, pin, chan);
			chan->requested = false;
			chan->is_interrupt = false;
		}
		break;
	case GPIO_RTIOC_REQS:
		ret = gpio_request(gpio, pin->name);
		if (ret)
			return ret;
		else
			chan->requested = true;
		break;
	case GPIO_RTIOC_RELS:
		gpio_free(gpio);
		chan->requested = false;
		break;
	case GPIO_RTIOC_TS_MONO:
	case GPIO_RTIOC_TS_REAL:
		ret = rtdm_safe_copy_from_user(fd, &val, arg, sizeof(val));
		if (ret)
			return ret;
		chan->want_timestamp = !!val;
		pin->monotonic_timestamp = request == GPIO_RTIOC_TS_MONO;
		break;
	default:
		return -EINVAL;
	}
	
	return ret;
}

static ssize_t gpio_pin_read_rt(struct rtdm_fd *fd,
				void __user *buf, size_t len)
{
	struct rtdm_gpio_chan *chan = rtdm_fd_to_private(fd);
	struct rtdm_device *dev = rtdm_fd_device(fd);
	struct rtdm_gpio_readout rdo;
	struct rtdm_gpio_pin *pin;
	int ret;

	if (!chan->has_direction)
		return -EAGAIN;

	if (chan->is_output)
		return -EINVAL;

	pin = container_of(dev, struct rtdm_gpio_pin, dev);

	if (chan->want_timestamp) {
		if (len < sizeof(rdo))
			return -EINVAL;

		if (!(fd->oflags & O_NONBLOCK)) {
			ret = rtdm_event_wait(&pin->event);
			if (ret)
				return ret;
			rdo.timestamp = pin->timestamp;
		} else if (pin->monotonic_timestamp) {
			rdo.timestamp = rtdm_clock_read_monotonic();
		} else {
			rdo.timestamp = rtdm_clock_read();
		}

		len = sizeof(rdo);
		rdo.value = gpiod_get_raw_value(pin->desc);
		ret = rtdm_safe_copy_to_user(fd, buf, &rdo, len);
	} else {
		if (len < sizeof(rdo.value))
			return -EINVAL;

		if (!(fd->oflags & O_NONBLOCK)) {
			ret = rtdm_event_wait(&pin->event);
			if (ret)
				return ret;
		}

		len = sizeof(rdo.value);
		rdo.value = gpiod_get_raw_value(pin->desc);
		ret = rtdm_safe_copy_to_user(fd, buf, &rdo.value, len);
	}
	
	return ret ?: len;
}

static ssize_t gpio_pin_write_rt(struct rtdm_fd *fd,
				 const void __user *buf, size_t len)
{
	struct rtdm_gpio_chan *chan = rtdm_fd_to_private(fd);
	struct rtdm_device *dev = rtdm_fd_device(fd);
	struct rtdm_gpio_pin *pin;
	int value, ret;

	if (len < sizeof(value))
		return -EINVAL;

	if (!chan->has_direction)
		return -EAGAIN;

	if (!chan->is_output)
		return -EINVAL;

	ret = rtdm_safe_copy_from_user(fd, &value, buf, sizeof(value));
	if (ret)
		return ret;

	pin = container_of(dev, struct rtdm_gpio_pin, dev);
	gpiod_set_raw_value(pin->desc, value);

	return sizeof(value);
}

static int gpio_pin_select(struct rtdm_fd *fd, struct xnselector *selector,
			   unsigned int type, unsigned int index)
{
	struct rtdm_gpio_chan *chan = rtdm_fd_to_private(fd);
	struct rtdm_device *dev = rtdm_fd_device(fd);
	struct rtdm_gpio_pin *pin;

	if (!chan->has_direction)
		return -EAGAIN;

	if (chan->is_output)
		return -EINVAL;

	pin = container_of(dev, struct rtdm_gpio_pin, dev);

	return rtdm_event_select(&pin->event, selector, type, index);
}

int gpio_pin_open(struct rtdm_fd *fd, int oflags)
{
	struct rtdm_gpio_chan *chan = rtdm_fd_to_private(fd);
	struct rtdm_device *dev = rtdm_fd_device(fd);
	unsigned int gpio = rtdm_fd_minor(fd);
	int ret = 0;
	struct rtdm_gpio_pin *pin;

	pin = container_of(dev, struct rtdm_gpio_pin, dev);
	ret = gpio_request(gpio, pin->name);
	if (ret) {
		printk(XENO_ERR "failed to request pin %d : %d\n", gpio, ret);
		return ret;
	} else {
		chan->requested = true;
	}

	return 0;
}

static void gpio_pin_close(struct rtdm_fd *fd)
{
	struct rtdm_gpio_chan *chan = rtdm_fd_to_private(fd);
	struct rtdm_device *dev = rtdm_fd_device(fd);
	unsigned int gpio = rtdm_fd_minor(fd);
	struct rtdm_gpio_pin *pin;

	if (chan->requested) {
		pin = container_of(dev, struct rtdm_gpio_pin, dev);
		release_gpio_irq(gpio, pin, chan);
	}
}

static void delete_pin_devices(struct rtdm_gpio_chip *rgc)
{
	struct rtdm_gpio_pin *pin;
	struct rtdm_device *dev;
	int offset;

	for (offset = 0; offset < rgc->gc->ngpio; offset++) {
		pin = rgc->pins + offset;
		dev = &pin->dev;
		rtdm_dev_unregister(dev);
		rtdm_event_destroy(&pin->event);
		kfree(dev->label);
		kfree(pin->name);
	}
}

static int create_pin_devices(struct rtdm_gpio_chip *rgc)
{
	struct gpio_chip *gc = rgc->gc;
	struct rtdm_gpio_pin *pin;
	struct rtdm_device *dev;
	int offset, ret, gpio;

	for (offset = 0; offset < gc->ngpio; offset++) {
		ret = -ENOMEM;
		gpio = gc->base + offset;
		pin = rgc->pins + offset;
		pin->name = kasprintf(GFP_KERNEL, "gpio%d", gpio);
		if (pin->name == NULL)
			goto fail_name;
		pin->desc = gpio_to_desc(gpio);
		if (pin->desc == NULL) {
			ret = -ENODEV;
			goto fail_desc;
		}
		dev = &pin->dev;
		dev->driver = &rgc->driver;
		dev->label = kasprintf(GFP_KERNEL, "%s/gpio%%d", gc->label);
		if (dev->label == NULL)
			goto fail_label;
		dev->minor = gpio;
		dev->device_data = rgc;
		ret = rtdm_dev_register(dev);
		if (ret)
			goto fail_register;
		rtdm_event_init(&pin->event, 0);
	}

	return 0;

fail_register:
	kfree(dev->label);
fail_desc:
fail_label:
	kfree(pin->name);
fail_name:
	delete_pin_devices(rgc);

	return ret;
}

static char *gpio_pin_devnode(struct device *dev, umode_t *mode)
{
	return kasprintf(GFP_KERNEL, "rtdm/%s/%s",
			 dev->class->name,
			 dev_name(dev));
}

int rtdm_gpiochip_add(struct rtdm_gpio_chip *rgc,
		      struct gpio_chip *gc, int gpio_subclass)
{
	int ret;

	rgc->devclass = class_create(gc->owner, gc->label);
	if (IS_ERR(rgc->devclass)) {
		printk(XENO_ERR "cannot create sysfs class\n");
		return PTR_ERR(rgc->devclass);
	}
	rgc->devclass->devnode = gpio_pin_devnode;

	rgc->driver.profile_info = (struct rtdm_profile_info)
		RTDM_PROFILE_INFO(rtdm_gpio_chip,
				  RTDM_CLASS_GPIO,
				  gpio_subclass,
				  0);
	rgc->driver.device_flags = RTDM_NAMED_DEVICE|RTDM_FIXED_MINOR;
	rgc->driver.base_minor = gc->base;
	rgc->driver.device_count = gc->ngpio;
	rgc->driver.context_size = sizeof(struct rtdm_gpio_chan);
	rgc->driver.ops = (struct rtdm_fd_ops){
		.open		=	gpio_pin_open,
		.close		=	gpio_pin_close,
		.ioctl_nrt	=	gpio_pin_ioctl_nrt,
		.read_rt	=	gpio_pin_read_rt,
		.write_rt	=	gpio_pin_write_rt,
		.select		=	gpio_pin_select,
	};
	
	rtdm_drv_set_sysclass(&rgc->driver, rgc->devclass);

	rgc->gc = gc;
	rtdm_lock_init(&rgc->lock);

	ret = create_pin_devices(rgc);
	if (ret)
		class_destroy(rgc->devclass);
	
	return ret;
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_add);

struct rtdm_gpio_chip *
rtdm_gpiochip_alloc(struct gpio_chip *gc, int gpio_subclass)
{
	struct rtdm_gpio_chip *rgc;
	size_t asize;
	int ret;

	if (gc->ngpio == 0)
		return ERR_PTR(-EINVAL);

	asize = sizeof(*rgc) + gc->ngpio * sizeof(struct rtdm_gpio_pin);
	rgc = kzalloc(asize, GFP_KERNEL);
	if (rgc == NULL)
		return ERR_PTR(-ENOMEM);

	ret = rtdm_gpiochip_add(rgc, gc, gpio_subclass);
	if (ret) {
		kfree(rgc);
		return ERR_PTR(ret);
	}

	mutex_lock(&chip_lock);
	list_add(&rgc->next, &rtdm_gpio_chips);
	mutex_unlock(&chip_lock);

	return rgc;
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_alloc);

void rtdm_gpiochip_remove(struct rtdm_gpio_chip *rgc)
{
	mutex_lock(&chip_lock);
	list_del(&rgc->next);
	mutex_unlock(&chip_lock);
	delete_pin_devices(rgc);
	class_destroy(rgc->devclass);
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_remove);

int rtdm_gpiochip_post_event(struct rtdm_gpio_chip *rgc,
			     unsigned int offset)
{
	struct rtdm_gpio_pin *pin;

	if (offset >= rgc->gc->ngpio)
		return -EINVAL;

	pin = rgc->pins + offset;
	if (pin->monotonic_timestamp)
		pin->timestamp = rtdm_clock_read_monotonic();
	else
		pin->timestamp = rtdm_clock_read();
	rtdm_event_signal(&pin->event);
	
	return 0;
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_post_event);

static int gpiochip_match_name(struct gpio_chip *chip, void *data)
{
	const char *name = data;

	return !strcmp(chip->label, name);
}

static struct gpio_chip *find_chip_by_name(const char *name)
{
	return gpiochip_find((void *)name, gpiochip_match_name);
}

int rtdm_gpiochip_add_by_name(struct rtdm_gpio_chip *rgc,
			      const char *label, int gpio_subclass)
{
	struct gpio_chip *gc = find_chip_by_name(label);

	if (gc == NULL)
		return -EPROBE_DEFER;

	return rtdm_gpiochip_add(rgc, gc, gpio_subclass);
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_add_by_name);

int rtdm_gpiochip_find(struct device_node *from, const char *label, int type)
{
	struct rtdm_gpio_chip *rgc;
	struct gpio_chip *chip;
	int ret = -ENODEV;

	if (!rtdm_available())
		return -ENOSYS;

	chip = find_chip_by_name(label);
	if (chip == NULL)
		return ret;

	ret = 0;
	rgc = rtdm_gpiochip_alloc(chip, type);
	if (IS_ERR(rgc))
		ret = PTR_ERR(rgc);

	return ret;
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_find);

int rtdm_gpiochip_array_find(struct device_node *from, const char *label[],
			     int nentries, int type)
{
	int ret = -ENODEV, _ret, n;

	for (n = 0; n < nentries; n++) {
		_ret = rtdm_gpiochip_find(from, label[n], type);
		if (_ret) {
			if (_ret != -ENODEV)
				return _ret;
		} else
			ret = 0;
	}

	return ret;
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_array_find);

#ifdef CONFIG_OF

#include <linux/of_platform.h>

struct gpiochip_holder {
	struct gpio_chip *chip;
	struct list_head next;
};
	
struct gpiochip_match_data {
	struct device *parent;
	struct list_head list;
};

static int match_gpio_chip(struct gpio_chip *gc, void *data)
{
	struct gpiochip_match_data *d = data;
	struct gpiochip_holder *h;

	if (cobalt_gpiochip_dev(gc) == d->parent) {
		h = kmalloc(sizeof(*h), GFP_KERNEL);
		if (h) {
			h->chip = gc;
			list_add(&h->next, &d->list);
		}
	}

	/*
	 * Iterate over all existing GPIO chips, we may have several
	 * hosted by the same pin controller mapping different ranges.
	 */
	return 0;
}

int rtdm_gpiochip_scan_of(struct device_node *from, const char *compat,
			  int type)
{
	struct gpiochip_match_data match;
	struct gpiochip_holder *h, *n;
	struct device_node *np = from;
	struct platform_device *pdev;
	struct rtdm_gpio_chip *rgc;
	int ret = -ENODEV, _ret;

	if (!rtdm_available())
		return -ENOSYS;

	for (;;) {
		np = of_find_compatible_node(np, NULL, compat);
		if (np == NULL)
			break;
		pdev = of_find_device_by_node(np);
		of_node_put(np);
		if (pdev == NULL)
			break;
		match.parent = &pdev->dev;
		INIT_LIST_HEAD(&match.list);
		gpiochip_find(&match, match_gpio_chip);
		if (!list_empty(&match.list)) {
			ret = 0;
			list_for_each_entry_safe(h, n, &match.list, next) {
				list_del(&h->next);
				_ret = 0;
				rgc = rtdm_gpiochip_alloc(h->chip, type);
				if (IS_ERR(rgc))
					_ret = PTR_ERR(rgc);
				kfree(h);
				if (_ret && !ret)
					ret = _ret;
			}
			if (ret)
				break;
		}
	}

	return ret;
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_scan_of);

int rtdm_gpiochip_scan_array_of(struct device_node *from,
				const char *compat[],
				int nentries, int type)
{
	int ret = -ENODEV, _ret, n;

	for (n = 0; n < nentries; n++) {
		_ret = rtdm_gpiochip_scan_of(from, compat[n], type);
		if (_ret) {
			if (_ret != -ENODEV)
				return _ret;
		} else
			ret = 0;
	}

	return ret;
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_scan_array_of);

#endif /* CONFIG_OF */

void rtdm_gpiochip_remove_by_type(int type)
{
	struct rtdm_gpio_chip *rgc, *n;

	mutex_lock(&chip_lock);

	list_for_each_entry_safe(rgc, n, &rtdm_gpio_chips, next) {
		if (rgc->driver.profile_info.subclass_id == type) {
			mutex_unlock(&chip_lock);
			rtdm_gpiochip_remove(rgc);
			kfree(rgc);
			mutex_lock(&chip_lock);
		}
	}

	mutex_unlock(&chip_lock);
}
EXPORT_SYMBOL_GPL(rtdm_gpiochip_remove_by_type);