/*
    comedi/drivers/cb_pcimdas.c
    Comedi driver for Computer Boards PCIM-DAS1602/16

    COMEDI - Linux Control and Measurement Device Interface
    Copyright (C) 2000 David A. Schleef <ds@schleef.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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/
/*
Driver: cb_pcimdas
Description: Measurement Computing PCI Migration series boards
Devices: [ComputerBoards] PCIM-DAS1602/16 (cb_pcimdas)
Author: Richard Bytheway
Updated: Wed, 13 Nov 2002 12:34:56 +0000
Status: experimental

Written to support the PCIM-DAS1602/16 on a 2.4 series kernel.

Configuration Options:
    [0] - PCI bus number
    [1] - PCI slot number

Developed from cb_pcidas and skel by Richard Bytheway (mocelet@sucs.org).
Only supports DIO, AO and simple AI in it's present form.
No interrupts, multi channel or FIFO AI, although the card looks like it could support this.
See http://www.measurementcomputing.com/PDFManuals/pcim-das1602_16.pdf for more details.
*/

#include "../comedidev.h"

#include <linux/delay.h>

#include "comedi_pci.h"
#include "plx9052.h"
#include "8255.h"

//#define CBPCIMDAS_DEBUG
#undef CBPCIMDAS_DEBUG

/* Registers for the PCIM-DAS1602/16 */

// sizes of io regions (bytes)
#define BADR0_SIZE 2            //??
#define BADR1_SIZE 4
#define BADR2_SIZE 6
#define BADR3_SIZE 16
#define BADR4_SIZE 4

//DAC Offsets
#define ADC_TRIG 0
#define DAC0_OFFSET 2
#define DAC1_OFFSET 4

//AI and Counter Constants
#define MUX_LIMITS 0
#define MAIN_CONN_DIO 1
#define ADC_STAT 2
#define ADC_CONV_STAT 3
#define ADC_INT 4
#define ADC_PACER 5
#define BURST_MODE 6
#define PROG_GAIN 7
#define CLK8254_1_DATA 8
#define CLK8254_2_DATA 9
#define CLK8254_3_DATA 10
#define CLK8254_CONTROL 11
#define USER_COUNTER 12
#define RESID_COUNT_H 13
#define RESID_COUNT_L 14

/* Board description */
struct cb_pcimdas_board {
        const char *name;
        unsigned short device_id;
        int ai_se_chans;        // Inputs in single-ended mode
        int ai_diff_chans;      // Inputs in differential mode
        int ai_bits;            // analog input resolution
        int ai_speed;           // fastest conversion period in ns
        int ao_nchan;           // number of analog out channels
        int ao_bits;            // analogue output resolution
        int has_ao_fifo;        // analog output has fifo
        int ao_scan_speed;      // analog output speed for 1602 series (for a scan, not conversion)
        int fifo_size;          // number of samples fifo can hold
        int dio_bits;           // number of dio bits
        int has_dio;            // has DIO
        const struct comedi_lrange *ranges;
};

static const struct cb_pcimdas_board cb_pcimdas_boards[] = {
        {
              name:     "PCIM-DAS1602/16",
              device_id:0x56,
              ai_se_chans:16,
              ai_diff_chans:8,
              ai_bits:  16,
              ai_speed:10000,   //??
              ao_nchan:2,
              ao_bits:  12,
              has_ao_fifo:0,    //??
              ao_scan_speed:10000,
                        //??
              fifo_size:1024,
              dio_bits:24,
              has_dio:  1,
//              ranges:         &cb_pcimdas_ranges,
                },
};

/* This is used by modprobe to translate PCI IDs to drivers.  Should
 * only be used for PCI and ISA-PnP devices */
static DEFINE_PCI_DEVICE_TABLE(cb_pcimdas_pci_table) = {
        {PCI_VENDOR_ID_COMPUTERBOARDS, 0x0056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
        {0}
};

MODULE_DEVICE_TABLE(pci, cb_pcimdas_pci_table);

#define N_BOARDS 1              // Max number of boards supported

/*
 * Useful for shorthand access to the particular board structure
 */
#define thisboard ((const struct cb_pcimdas_board *)dev->board_ptr)

/* this structure is for data unique to this hardware driver.  If
   several hardware drivers keep similar information in this structure,
   feel free to suggest moving the variable to the struct comedi_device struct.  */
struct cb_pcimdas_private {
        int data;

        // would be useful for a PCI device
        struct pci_dev *pci_dev;

        //base addresses
        unsigned long BADR0;
        unsigned long BADR1;
        unsigned long BADR2;
        unsigned long BADR3;
        unsigned long BADR4;

        /* Used for AO readback */
        unsigned int ao_readback[2];

        // Used for DIO
        unsigned short int port_a;      // copy of BADR4+0
        unsigned short int port_b;      // copy of BADR4+1
        unsigned short int port_c;      // copy of BADR4+2
        unsigned short int dio_mode;    // copy of BADR4+3

};

/*
 * most drivers define the following macro to make it easy to
 * access the private structure.
 */
#define devpriv ((struct cb_pcimdas_private *)dev->private)

/*
 * The struct comedi_driver structure tells the Comedi core module
 * which functions to call to configure/deconfigure (attach/detach)
 * the board, and also about the kernel module that contains
 * the device code.
 */
static int cb_pcimdas_attach(struct comedi_device * dev, struct comedi_devconfig * it);
static int cb_pcimdas_detach(struct comedi_device * dev);
static struct comedi_driver driver_cb_pcimdas = {
      driver_name:"cb_pcimdas",
      module:THIS_MODULE,
      attach:cb_pcimdas_attach,
      detach:cb_pcimdas_detach,
};

static int cb_pcimdas_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
        struct comedi_insn * insn, unsigned int * data);
static int cb_pcimdas_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
        struct comedi_insn * insn, unsigned int * data);
static int cb_pcimdas_ao_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
        struct comedi_insn * insn, unsigned int * data);

/*
 * Attach is called by the Comedi core to configure the driver
 * for a particular board.  If you specified a board_name array
 * in the driver structure, dev->board_ptr contains that
 * address.
 */
static int cb_pcimdas_attach(struct comedi_device * dev, struct comedi_devconfig * it)
{
        struct comedi_subdevice *s;
        struct pci_dev *pcidev;
        int index;
        //int i;

        printk("comedi%d: cb_pcimdas: ", dev->minor);

/*
 * Allocate the private structure area.
 */
        if (alloc_private(dev, sizeof(struct cb_pcimdas_private)) < 0)
                return -ENOMEM;

/*
 * Probe the device to determine what device in the series it is.
 */
        printk("\n");

        for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
                pcidev != NULL;
                pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
                // is it not a computer boards card?
                if (pcidev->vendor != PCI_VENDOR_ID_COMPUTERBOARDS)
                        continue;
                // loop through cards supported by this driver
                for (index = 0; index < N_BOARDS; index++) {
                        if (cb_pcimdas_boards[index].device_id !=
                                pcidev->device)
                                continue;
                        // was a particular bus/slot requested?
                        if (it->options[0] || it->options[1]) {
                                // are we on the wrong bus/slot?
                                if (pcidev->bus->number != it->options[0] ||
                                        PCI_SLOT(pcidev->devfn) !=
                                        it->options[1]) {
                                        continue;
                                }
                        }
                        devpriv->pci_dev = pcidev;
                        dev->board_ptr = cb_pcimdas_boards + index;
                        goto found;
                }
        }

        printk("No supported ComputerBoards/MeasurementComputing card found on "
                "requested position\n");
        return -EIO;

      found:

        printk("Found %s on bus %i, slot %i\n", cb_pcimdas_boards[index].name,
                pcidev->bus->number, PCI_SLOT(pcidev->devfn));

        // Warn about non-tested features
        switch (thisboard->device_id) {
        case 0x56:
                break;
        default:
                printk("THIS CARD IS UNSUPPORTED.\n"
                        "PLEASE REPORT USAGE TO <mocelet@sucs.org>\n");
        };

        if (comedi_pci_enable(pcidev, "cb_pcimdas")) {
                printk(" Failed to enable PCI device and request regions\n");
                return -EIO;
        }

        devpriv->BADR0 = pci_resource_start(devpriv->pci_dev, 0);
        devpriv->BADR1 = pci_resource_start(devpriv->pci_dev, 1);
        devpriv->BADR2 = pci_resource_start(devpriv->pci_dev, 2);
        devpriv->BADR3 = pci_resource_start(devpriv->pci_dev, 3);
        devpriv->BADR4 = pci_resource_start(devpriv->pci_dev, 4);

#ifdef CBPCIMDAS_DEBUG
        printk("devpriv->BADR0 = 0x%lx\n", devpriv->BADR0);
        printk("devpriv->BADR1 = 0x%lx\n", devpriv->BADR1);
        printk("devpriv->BADR2 = 0x%lx\n", devpriv->BADR2);
        printk("devpriv->BADR3 = 0x%lx\n", devpriv->BADR3);
        printk("devpriv->BADR4 = 0x%lx\n", devpriv->BADR4);
#endif

// Dont support IRQ yet
//      // get irq
//      if(comedi_request_irq(devpriv->pci_dev->irq, cb_pcimdas_interrupt, IRQF_SHARED, "cb_pcimdas", dev ))
//      {
//              printk(" unable to allocate irq %u\n", devpriv->pci_dev->irq);
//              return -EINVAL;
//      }
//      dev->irq = devpriv->pci_dev->irq;

        //Initialize dev->board_name
        dev->board_name = thisboard->name;

/*
 * Allocate the subdevice structures.  alloc_subdevice() is a
 * convenient macro defined in comedidev.h.
 */
        if (alloc_subdevices(dev, 3) < 0)
                return -ENOMEM;

        s = dev->subdevices + 0;
        //dev->read_subdev=s;
        // analog input subdevice
        s->type = COMEDI_SUBD_AI;
        s->subdev_flags = SDF_READABLE | SDF_GROUND;
        s->n_chan = thisboard->ai_se_chans;
        s->maxdata = (1 << thisboard->ai_bits) - 1;
        s->range_table = &range_unknown;
        s->len_chanlist = 1;    // This is the maximum chanlist length that
        // the board can handle
        s->insn_read = cb_pcimdas_ai_rinsn;

        s = dev->subdevices + 1;
        // analog output subdevice
        s->type = COMEDI_SUBD_AO;
        s->subdev_flags = SDF_WRITABLE;
        s->n_chan = thisboard->ao_nchan;
        s->maxdata = 1 << thisboard->ao_bits;
        s->range_table = &range_unknown;        //ranges are hardware settable, but not software readable.
        s->insn_write = &cb_pcimdas_ao_winsn;
        s->insn_read = &cb_pcimdas_ao_rinsn;

        s = dev->subdevices + 2;
        /* digital i/o subdevice */
        if (thisboard->has_dio) {
                subdev_8255_init(dev, s, NULL, devpriv->BADR4);
        } else {
                s->type = COMEDI_SUBD_UNUSED;
        }

        printk("attached\n");

        return 1;
}

/*
 * _detach is called to deconfigure a device.  It should deallocate
 * resources.
 * This function is also called when _attach() fails, so it should be
 * careful not to release resources that were not necessarily
 * allocated by _attach().  dev->private and dev->subdevices are
 * deallocated automatically by the core.
 */
static int cb_pcimdas_detach(struct comedi_device * dev)
{
#ifdef CBPCIMDAS_DEBUG
        if (devpriv) {
                printk("devpriv->BADR0 = 0x%lx\n", devpriv->BADR0);
                printk("devpriv->BADR1 = 0x%lx\n", devpriv->BADR1);
                printk("devpriv->BADR2 = 0x%lx\n", devpriv->BADR2);
                printk("devpriv->BADR3 = 0x%lx\n", devpriv->BADR3);
                printk("devpriv->BADR4 = 0x%lx\n", devpriv->BADR4);
        }
#endif
        printk("comedi%d: cb_pcimdas: remove\n", dev->minor);
        if (dev->irq)
                comedi_free_irq(dev->irq, dev);
        if (devpriv) {
                if (devpriv->pci_dev) {
                        if (devpriv->BADR0) {
                                comedi_pci_disable(devpriv->pci_dev);
                        }
                        pci_dev_put(devpriv->pci_dev);
                }
        }

        return 0;
}

/*
 * "instructions" read/write data in "one-shot" or "software-triggered"
 * mode.
 */
static int cb_pcimdas_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
        struct comedi_insn * insn, unsigned int * data)
{
        int n, i;
        unsigned int d;
        unsigned int busy;
        int chan = CR_CHAN(insn->chanspec);
        unsigned short chanlims;
        int maxchans;

        // only support sw initiated reads from a single channel

        //check channel number
        if ((inb(devpriv->BADR3 + 2) & 0x20) == 0)      //differential mode
                maxchans = thisboard->ai_diff_chans;
        else
                maxchans = thisboard->ai_se_chans;

        if (chan > (maxchans - 1))
                return -ETIMEDOUT;      //*** Wrong error code. Fixme.

        //configure for sw initiated read
        d = inb(devpriv->BADR3 + 5);
        if ((d & 0x03) > 0) {   //only reset if needed.
                d = d & 0xfd;
                outb(d, devpriv->BADR3 + 5);
        }
        outb(0x01, devpriv->BADR3 + 6); //set bursting off, conversions on
        outb(0x00, devpriv->BADR3 + 7); //set range to 10V. UP/BP is controlled by a switch on the board

        // write channel limits to multiplexer, set Low (bits 0-3) and High (bits 4-7) channels to chan.
        chanlims = chan | (chan << 4);
        outb(chanlims, devpriv->BADR3 + 0);

        /* convert n samples */
        for (n = 0; n < insn->n; n++) {
                /* trigger conversion */
                outw(0, devpriv->BADR2 + 0);

#define TIMEOUT 1000            //typically takes 5 loops on a lightly loaded Pentium 100MHz,
                //this is likely to be 100 loops on a 2GHz machine, so set 1000 as the limit.

                /* wait for conversion to end */
                for (i = 0; i < TIMEOUT; i++) {
                        busy = inb(devpriv->BADR3 + 2) & 0x80;
                        if (!busy)
                                break;
                }
                if (i == TIMEOUT) {
                        printk("timeout\n");
                        return -ETIMEDOUT;
                }
                /* read data */
                d = inw(devpriv->BADR2 + 0);

                /* mangle the data as necessary */
                //d ^= 1<<(thisboard->ai_bits-1); // 16 bit data from ADC, so no mangle needed.

                data[n] = d;
        }

        /* return the number of samples read/written */
        return n;
}

static int cb_pcimdas_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s,
        struct comedi_insn * insn, unsigned int * data)
{
        int i;
        int chan = CR_CHAN(insn->chanspec);

        /* Writing a list of values to an AO channel is probably not
         * very useful, but that's how the interface is defined. */
        for (i = 0; i < insn->n; i++) {
                switch (chan) {
                case 0:
                        outw(data[i] & 0x0FFF, devpriv->BADR2 + DAC0_OFFSET);
                        break;
                case 1:
                        outw(data[i] & 0x0FFF, devpriv->BADR2 + DAC1_OFFSET);
                        break;
                default:
                        return -1;
                }
                devpriv->ao_readback[chan] = data[i];
        }

        /* return the number of samples read/written */
        return i;
}

/* AO subdevices should have a read insn as well as a write insn.
 * Usually this means copying a value stored in devpriv. */
static int cb_pcimdas_ao_rinsn(struct comedi_device * dev, struct comedi_subdevice * s,
        struct comedi_insn * insn, unsigned int * data)
{
        int i;
        int chan = CR_CHAN(insn->chanspec);

        for (i = 0; i < insn->n; i++)
                data[i] = devpriv->ao_readback[chan];

        return i;
}

/*
 * A convenient macro that defines init_module() and cleanup_module(),
 * as necessary.
 */
COMEDI_PCI_INITCLEANUP(driver_cb_pcimdas, cb_pcimdas_pci_table);