/*
 * Analogy subdevice driver for 8255 chip
 * Copyright (C) 1999 David A. Schleef <ds@schleef.org>
 *
 * This code 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 code 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 Xenomai; 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/ioport.h>
#include <linux/io.h>
#include <rtdm/analogy/device.h>

#include "8255.h"

#define CALLBACK_ARG		(((subd_8255_t *)subd->priv)->cb_arg)
#define CALLBACK_FUNC		(((subd_8255_t *)subd->priv)->cb_func)

/* Channels descriptor */
static struct a4l_channels_desc chandesc_8255 = {
	.mode = A4L_CHAN_GLOBAL_CHANDESC,
	.length = 24,
	.chans = {
		{A4L_CHAN_AREF_GROUND, sizeof(sampl_t)},
	},
};

/* Command options mask */
static struct a4l_cmd_desc cmd_mask_8255 = {
	.idx_subd = 0,
	.start_src = TRIG_NOW,
	.scan_begin_src = TRIG_EXT,
	.convert_src = TRIG_FOLLOW,
	.scan_end_src = TRIG_COUNT,
	.stop_src = TRIG_NONE,
};

void a4l_subdev_8255_interrupt(struct a4l_subdevice *subd)
{
	sampl_t d;

	/* Retrieve the sample... */
	d = CALLBACK_FUNC(0, _8255_DATA, 0, CALLBACK_ARG);
	d |= (CALLBACK_FUNC(0, _8255_DATA + 1, 0, CALLBACK_ARG) << 8);

	/* ...and send it */
	a4l_buf_put(subd, &d, sizeof(sampl_t));

	a4l_buf_evt(subd, 0);
}
EXPORT_SYMBOL_GPL(a4l_subdev_8255_interrupt);

static int subdev_8255_cb(int dir, int port, int data, unsigned long arg)
{
	unsigned long iobase = arg;

	if (dir) {
		outb(data, iobase + port);
		return 0;
	} else {
		return inb(iobase + port);
	}
}

static void do_config(struct a4l_subdevice *subd)
{
	int config;
	subd_8255_t *subd_8255 = (subd_8255_t *)subd->priv;

	config = CR_CW;
	/* 1 in io_bits indicates output, 1 in config indicates input */
	if (!(subd_8255->io_bits & 0x0000ff))
		config |= CR_A_IO;
	if (!(subd_8255->io_bits & 0x00ff00))
		config |= CR_B_IO;
	if (!(subd_8255->io_bits & 0x0f0000))
		config |= CR_C_LO_IO;
	if (!(subd_8255->io_bits & 0xf00000))
		config |= CR_C_HI_IO;
	CALLBACK_FUNC(1, _8255_CR, config, CALLBACK_ARG);
}

int subd_8255_cmd(struct a4l_subdevice *subd, struct a4l_cmd_desc *cmd)
{
	/* FIXME */
	return 0;
}

int subd_8255_cmdtest(struct a4l_subdevice *subd, struct a4l_cmd_desc *cmd)
{
	if (cmd->start_arg != 0) {
		cmd->start_arg = 0;
		return -EINVAL;
	}
	if (cmd->scan_begin_arg != 0) {
		cmd->scan_begin_arg = 0;
		return -EINVAL;
	}
	if (cmd->convert_arg != 0) {
		cmd->convert_arg = 0;
		return -EINVAL;
	}
	if (cmd->scan_end_arg != 1) {
		cmd->scan_end_arg = 1;
		return -EINVAL;
	}
	if (cmd->stop_arg != 0) {
		cmd->stop_arg = 0;
		return -EINVAL;
	}

	return 0;
}

void subd_8255_cancel(struct a4l_subdevice *subd)
{
	/* FIXME */
}

int subd_8255_insn_bits(struct a4l_subdevice *subd, struct a4l_kernel_instruction *insn)
{
	subd_8255_t *subd_8255 = (subd_8255_t *)subd->priv;
	uint32_t *data = (uint32_t *)insn->data;

	if (data[0]) {

		subd_8255->status &= ~data[0];
		subd_8255->status |= (data[0] & data[1]);

		if (data[0] & 0xff)
			CALLBACK_FUNC(1, _8255_DATA,
				      subd_8255->status & 0xff, CALLBACK_ARG);
		if (data[0] & 0xff00)
			CALLBACK_FUNC(1, _8255_DATA + 1,
				      (subd_8255->status >> 8) & 0xff,
				      CALLBACK_ARG);
		if (data[0] & 0xff0000)
			CALLBACK_FUNC(1, _8255_DATA + 2,
				      (subd_8255->status >> 16) & 0xff,
				      CALLBACK_ARG);
	}

	data[1] = CALLBACK_FUNC(0, _8255_DATA, 0, CALLBACK_ARG);
	data[1] |= (CALLBACK_FUNC(0, _8255_DATA + 1, 0, CALLBACK_ARG) << 8);
	data[1] |= (CALLBACK_FUNC(0, _8255_DATA + 2, 0, CALLBACK_ARG) << 16);

	return 0;
}

int subd_8255_insn_config(struct a4l_subdevice *subd, struct a4l_kernel_instruction *insn)
{
	unsigned int mask;
	unsigned int bits;
	subd_8255_t *subd_8255 = (subd_8255_t *)subd->priv;
	unsigned int *data = (unsigned int *)insn->data;

	mask = 1 << CR_CHAN(insn->chan_desc);

	if (mask & 0x0000ff) {
		bits = 0x0000ff;
	} else if (mask & 0x00ff00) {
		bits = 0x00ff00;
	} else if (mask & 0x0f0000) {
		bits = 0x0f0000;
	} else {
		bits = 0xf00000;
	}

	switch (data[0]) {
	case A4L_INSN_CONFIG_DIO_INPUT:
		subd_8255->io_bits &= ~bits;
		break;
	case A4L_INSN_CONFIG_DIO_OUTPUT:
		subd_8255->io_bits |= bits;
		break;
	case A4L_INSN_CONFIG_DIO_QUERY:
		data[1] = (subd_8255->io_bits & bits) ?
			A4L_OUTPUT : A4L_INPUT;
		return 0;
		break;
	default:
		return -EINVAL;
	}

	do_config(subd);

	return 0;
}

void a4l_subdev_8255_init(struct a4l_subdevice *subd)
{
	subd_8255_t *subd_8255 = (subd_8255_t *)subd->priv;
	/* Initializes the subdevice structure */
	memset(subd, 0, sizeof(struct a4l_subdevice));

	/* Subdevice filling part */

	subd->flags = A4L_SUBD_DIO;
	subd->flags |= A4L_SUBD_CMD;
	subd->chan_desc = &chandesc_8255;
	subd->insn_bits = subd_8255_insn_bits;
	subd->insn_config = subd_8255_insn_config;

	if(subd_8255->have_irq) {
		subd->cmd_mask = &cmd_mask_8255;
		subd->do_cmdtest = subd_8255_cmdtest;
		subd->do_cmd = subd_8255_cmd;
		subd->cancel = subd_8255_cancel;
	}

	/* 8255 setting part */

	if(CALLBACK_FUNC == NULL)
		CALLBACK_FUNC = subdev_8255_cb;

	do_config(subd);
}
EXPORT_SYMBOL_GPL(a4l_subdev_8255_init);

/*

  Start of the 8255 standalone device

*/

static int dev_8255_attach(struct a4l_device *dev, a4l_lnkdesc_t *arg)
{
	unsigned long *addrs;
	int i, err = 0;

	if(arg->opts == NULL || arg->opts_size == 0) {
		a4l_err(dev,
			"dev_8255_attach: unable to detect any 8255 chip, "
			"chips addresses must be passed as attach arguments\n");
		return -EINVAL;
	}

	addrs = (unsigned long*) arg->opts;

	for(i = 0; i < (arg->opts_size / sizeof(unsigned long)); i++) {
		struct a4l_subdevice * subd;
		subd_8255_t *subd_8255;

		subd = a4l_alloc_subd(sizeof(subd_8255_t), NULL);
		if(subd == NULL) {
			a4l_err(dev,
				"dev_8255_attach: "
				"unable to allocate subdevice\n");
			/* There is no need to free previously
			   allocated structure(s), the analogy layer will
			   do it for us */
			err = -ENOMEM;
			goto out_attach;
		}

		memset(subd, 0, sizeof(struct a4l_subdevice));
		memset(subd->priv, 0, sizeof(subd_8255_t));

		subd_8255 = (subd_8255_t *)subd->priv;

		if(request_region(addrs[i], _8255_SIZE, "Analogy 8255") == 0) {
			subd->flags = A4L_SUBD_UNUSED;
			a4l_warn(dev,
				 "dev_8255_attach: "
				 "I/O port conflict at 0x%lx\n", addrs[i]);
		}
		else {
			subd_8255->cb_arg = addrs[i];
			a4l_subdev_8255_init(subd);
		}

		err = a4l_add_subd(dev, subd);
		if(err < 0) {
			a4l_err(dev,
				"dev_8255_attach: "
				"a4l_add_subd() failed (err=%d)\n", err);
			goto out_attach;
		}
	}

out_attach:
	return err;
}

static int dev_8255_detach(struct a4l_device *dev)
{
	struct a4l_subdevice *subd;
	int i = 0;

	while((subd = a4l_get_subd(dev, i++)) != NULL) {
		subd_8255_t *subd_8255 = (subd_8255_t *) subd->priv;
		if(subd_8255 != NULL && subd_8255->cb_arg != 0)
			release_region(subd_8255->cb_arg, _8255_SIZE);
	}

	return 0;
}

static struct a4l_driver drv_8255 = {
	.owner = THIS_MODULE,
	.board_name = "analogy_8255",
	.driver_name = "8255",
	.attach = dev_8255_attach,
	.detach = dev_8255_detach,
	.privdata_size = 0,
};

static int __init drv_8255_init(void)
{
	return a4l_register_drv(&drv_8255);
}

static void __exit drv_8255_cleanup(void)
{
	a4l_unregister_drv(&drv_8255);
}
MODULE_DESCRIPTION("Analogy driver for 8255 chip");
MODULE_LICENSE("GPL");

module_init(drv_8255_init);
module_exit(drv_8255_cleanup);