/**
 * @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/slab.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/spi/spi.h>
#include <linux/gpio.h>
#include "spi-master.h"

static inline
struct device *to_kdev(struct rtdm_spi_remote_slave *slave)
{
	return rtdm_dev_to_kdev(&slave->dev);
}

static inline struct rtdm_spi_remote_slave *fd_to_slave(struct rtdm_fd *fd)
{
	struct rtdm_device *dev = rtdm_fd_device(fd);

	return container_of(dev, struct rtdm_spi_remote_slave, dev);
}

static int update_slave_config(struct rtdm_spi_remote_slave *slave,
			       struct rtdm_spi_config *config)
{
	struct rtdm_spi_config old_config;
	struct rtdm_spi_master *master = slave->master;
	int ret;

	rtdm_mutex_lock(&master->bus_lock);

	old_config = slave->config;
	slave->config = *config;
	ret = slave->master->ops->configure(slave);
	if (ret) {
		slave->config = old_config;
		rtdm_mutex_unlock(&master->bus_lock);
		return ret;
	}

	rtdm_mutex_unlock(&master->bus_lock);
	
	dev_info(to_kdev(slave),
		 "configured mode %d, %s%s%s%s%u bits/w, %u Hz max\n",
		 (int) (slave->config.mode & (SPI_CPOL | SPI_CPHA)),
		 (slave->config.mode & SPI_CS_HIGH) ? "cs_high, " : "",
		 (slave->config.mode & SPI_LSB_FIRST) ? "lsb, " : "",
		 (slave->config.mode & SPI_3WIRE) ? "3wire, " : "",
		 (slave->config.mode & SPI_LOOP) ? "loopback, " : "",
		 slave->config.bits_per_word,
		 slave->config.speed_hz);
	
	return 0;
}

static int spi_master_open(struct rtdm_fd *fd, int oflags)
{
	struct rtdm_spi_remote_slave *slave = fd_to_slave(fd);
	struct rtdm_spi_master *master = slave->master;

	if (master->ops->open)
		return master->ops->open(slave);
		
	return 0;
}

static void spi_master_close(struct rtdm_fd *fd)
{
	struct rtdm_spi_remote_slave *slave = fd_to_slave(fd);
	struct rtdm_spi_master *master = slave->master;
	rtdm_lockctx_t c;

	rtdm_lock_get_irqsave(&master->lock, c);

	if (master->cs == slave)
		master->cs = NULL;

	rtdm_lock_put_irqrestore(&master->lock, c);

	if (master->ops->close)
		master->ops->close(slave);
}

static int do_chip_select(struct rtdm_spi_remote_slave *slave)
{				/* master->bus_lock held */
	struct rtdm_spi_master *master = slave->master;
	rtdm_lockctx_t c;
	int state;

	if (slave->config.speed_hz == 0)
		return -EINVAL; /* Setup is missing. */

	/* Serialize with spi_master_close() */
	rtdm_lock_get_irqsave(&master->lock, c);
	
	if (master->cs != slave) {
		if (slave->cs_gpiod) {
			state = !!(slave->config.mode & SPI_CS_HIGH);
			gpiod_set_raw_value(slave->cs_gpiod, state);
		} else
			master->ops->chip_select(slave, true);
		master->cs = slave;
	}

	rtdm_lock_put_irqrestore(&master->lock, c);

	return 0;
}

static void do_chip_deselect(struct rtdm_spi_remote_slave *slave)
{				/* master->bus_lock held */
	struct rtdm_spi_master *master = slave->master;
	rtdm_lockctx_t c;
	int state;

	rtdm_lock_get_irqsave(&master->lock, c);

	if (slave->cs_gpiod) {
		state = !(slave->config.mode & SPI_CS_HIGH);
		gpiod_set_raw_value(slave->cs_gpiod, state);
	} else
		master->ops->chip_select(slave, false);

	master->cs = NULL;

	rtdm_lock_put_irqrestore(&master->lock, c);
}

static int spi_master_ioctl_rt(struct rtdm_fd *fd,
			       unsigned int request, void *arg)
{
	struct rtdm_spi_remote_slave *slave = fd_to_slave(fd);
	struct rtdm_spi_master *master = slave->master;
	struct rtdm_spi_config config;
	int ret, len;

	switch (request) {
	case SPI_RTIOC_SET_CONFIG:
		ret = rtdm_safe_copy_from_user(fd, &config,
					       arg, sizeof(config));
		if (ret == 0)
			ret = update_slave_config(slave, &config);
		break;
	case SPI_RTIOC_GET_CONFIG:
		rtdm_mutex_lock(&master->bus_lock);
		config = slave->config;
		rtdm_mutex_unlock(&master->bus_lock);
		ret = rtdm_safe_copy_to_user(fd, arg,
					     &config, sizeof(config));
		break;
	case SPI_RTIOC_TRANSFER:
		ret = -EINVAL;
		if (master->ops->transfer_iobufs) {
			rtdm_mutex_lock(&master->bus_lock);
			ret = do_chip_select(slave);
			if (ret == 0) {
				ret = master->ops->transfer_iobufs(slave);
				do_chip_deselect(slave);
			}
			rtdm_mutex_unlock(&master->bus_lock);
		}
		break;
	case SPI_RTIOC_TRANSFER_N:
		ret = -EINVAL;
		if (master->ops->transfer_iobufs_n) {
			len = (long)arg;
			rtdm_mutex_lock(&master->bus_lock);
			ret = do_chip_select(slave);
			if (ret == 0) {
				ret = master->ops->transfer_iobufs_n(slave, len);
				do_chip_deselect(slave);
			}
			rtdm_mutex_unlock(&master->bus_lock);
		}
		break;
	default:
		ret = -ENOSYS;
	}

	return ret;
}

static int spi_master_ioctl_nrt(struct rtdm_fd *fd,
				unsigned int request, void *arg)
{
	struct rtdm_spi_remote_slave *slave = fd_to_slave(fd);
	struct rtdm_spi_master *master = slave->master;
	struct rtdm_spi_iobufs iobufs;
	int ret;

	switch (request) {
	case SPI_RTIOC_SET_IOBUFS:
		ret = rtdm_safe_copy_from_user(fd, &iobufs,
					       arg, sizeof(iobufs));
		if (ret)
			break;
		/*
		 * No transfer can happen without I/O buffers being
		 * set, and I/O buffers cannot be reset, therefore we
		 * need no serialization with the transfer code here.
		 */
		mutex_lock(&slave->ctl_lock);
		ret = master->ops->set_iobufs(slave, &iobufs);
		mutex_unlock(&slave->ctl_lock);
		if (ret == 0)
			ret = rtdm_safe_copy_to_user(fd, arg,
					     &iobufs, sizeof(iobufs));
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}

static ssize_t spi_master_read_rt(struct rtdm_fd *fd,
				  void __user *u_buf, size_t len)
{
	struct rtdm_spi_remote_slave *slave = fd_to_slave(fd);
	struct rtdm_spi_master *master = slave->master;
	void *rx;
	int ret;

	if (len == 0)
		return 0;

	rx = xnmalloc(len);
	if (rx == NULL)
		return -ENOMEM;

	rtdm_mutex_lock(&master->bus_lock);
	ret = do_chip_select(slave);
	if (ret == 0) {
		ret = master->ops->read(slave, rx, len);
		do_chip_deselect(slave);
	}
	rtdm_mutex_unlock(&master->bus_lock);
	if (ret > 0)
		ret = rtdm_safe_copy_to_user(fd, u_buf, rx, ret);
	
	xnfree(rx);
	
	return ret;
}

static ssize_t spi_master_write_rt(struct rtdm_fd *fd,
				   const void __user *u_buf, size_t len)
{
	struct rtdm_spi_remote_slave *slave = fd_to_slave(fd);
	struct rtdm_spi_master *master = slave->master;
	void *tx;
	int ret;

	if (len == 0)
		return 0;

	tx = xnmalloc(len);
	if (tx == NULL)
		return -ENOMEM;

	ret = rtdm_safe_copy_from_user(fd, tx, u_buf, len);
	if (ret == 0) {
		rtdm_mutex_lock(&master->bus_lock);
		ret = do_chip_select(slave);
		if (ret == 0) {
			ret = master->ops->write(slave, tx, len);
			do_chip_deselect(slave);
		}
		rtdm_mutex_unlock(&master->bus_lock);
	}
	
	xnfree(tx);

	return ret;
}

static void iobufs_vmopen(struct vm_area_struct *vma)
{
	struct rtdm_spi_remote_slave *slave = vma->vm_private_data;

	atomic_inc(&slave->mmap_refs);
	dev_dbg(slave_to_kdev(slave), "mapping added\n");
}

static void iobufs_vmclose(struct vm_area_struct *vma)
{
	struct rtdm_spi_remote_slave *slave = vma->vm_private_data;

	if (atomic_dec_and_test(&slave->mmap_refs)) {
		slave->master->ops->mmap_release(slave);
		dev_dbg(slave_to_kdev(slave), "mapping released\n");
	}
}

static struct vm_operations_struct iobufs_vmops = {
	.open = iobufs_vmopen,
	.close = iobufs_vmclose,
};

static int spi_master_mmap(struct rtdm_fd *fd, struct vm_area_struct *vma)
{
	struct rtdm_spi_remote_slave *slave = fd_to_slave(fd);
	int ret;

	if (slave->master->ops->mmap_iobufs == NULL)
		return -EINVAL;

	ret = slave->master->ops->mmap_iobufs(slave, vma);
	if (ret)
		return ret;

	dev_dbg(slave_to_kdev(slave), "mapping created\n");
	atomic_inc(&slave->mmap_refs);

	if (slave->master->ops->mmap_release) {
		vma->vm_ops = &iobufs_vmops;
		vma->vm_private_data = slave;
	}

	return 0;
}

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

struct rtdm_spi_master *
__rtdm_spi_alloc_master(struct device *dev, size_t size, int off)
{
	struct rtdm_spi_master *master;
	struct spi_controller *ctlr;

	ctlr = spi_alloc_master(dev, size);
	if (ctlr == NULL)
		return NULL;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0)
	ctlr->use_gpio_descriptors = true;
#endif
	master = (void *)(ctlr + 1) + off;
	master->controller = ctlr;
	spi_master_set_devdata(ctlr, master);

	return master;
}
EXPORT_SYMBOL_GPL(__rtdm_spi_alloc_master);

int __rtdm_spi_setup_driver(struct rtdm_spi_master *master)
{
	master->classname = kstrdup(
		dev_name(&master->controller->dev), GFP_KERNEL);
	master->devclass = class_create(THIS_MODULE,
		master->classname);
	if (IS_ERR(master->devclass)) {
		kfree(master->classname);
		printk(XENO_ERR "cannot create sysfs class\n");
		return PTR_ERR(master->devclass);
	}

	master->devclass->devnode = spi_slave_devnode;
	master->cs = NULL;

	master->driver.profile_info = (struct rtdm_profile_info)
		RTDM_PROFILE_INFO(rtdm_spi_master,
				  RTDM_CLASS_SPI,
				  master->subclass,
				  0);
	master->driver.device_flags = RTDM_NAMED_DEVICE;
	master->driver.base_minor = 0;
	master->driver.device_count = 256;
	master->driver.context_size = 0;
	master->driver.ops = (struct rtdm_fd_ops){
		.open		=	spi_master_open,
		.close		=	spi_master_close,
		.read_rt	=	spi_master_read_rt,
		.write_rt	=	spi_master_write_rt,
		.ioctl_rt	=	spi_master_ioctl_rt,
		.ioctl_nrt	=	spi_master_ioctl_nrt,
		.mmap		=	spi_master_mmap,
	};
	
	rtdm_drv_set_sysclass(&master->driver, master->devclass);

	INIT_LIST_HEAD(&master->slaves);
	rtdm_lock_init(&master->lock);
	rtdm_mutex_init(&master->bus_lock);

	return 0;
}

static int spi_transfer_one_unimp(struct spi_master *master,
				  struct spi_device *spi,
				  struct spi_transfer *tfr)
{
	return -ENODEV;
}

int rtdm_spi_add_master(struct rtdm_spi_master *master)
{
	struct spi_controller *ctlr = master->controller;

	/*
	 * Prevent the transfer handler to be called from the regular
	 * SPI stack, just in case.
	 */
	ctlr->transfer_one = spi_transfer_one_unimp;
	master->devclass = NULL;

	/*
	 * Add the core SPI driver, devices on the bus will be
	 * enumerated, handed to spi_device_probe().
	 */
	return spi_register_controller(ctlr);
}
EXPORT_SYMBOL_GPL(rtdm_spi_add_master);

void rtdm_spi_remove_master(struct rtdm_spi_master *master)
{
	struct class *class = master->devclass;
	char *classname = master->classname;
	
	rtdm_mutex_destroy(&master->bus_lock);
	spi_unregister_controller(master->controller);
	rtdm_drv_set_sysclass(&master->driver, NULL);
	class_destroy(class);
	kfree(classname);
}
EXPORT_SYMBOL_GPL(rtdm_spi_remove_master);

MODULE_LICENSE("GPL");