// SPDX-License-Identifier: GPL-2.0+
/*
 *  Copyright (C) 2004-2019 Bernd Porr, mail@berndporr.me.uk
 */

/*
 * Driver: usbduxfast
 * Description: University of Stirling USB DAQ & INCITE Technology Limited
 * Devices: [ITL] USB-DUX-FAST (usbduxfast)
 * Author: Bernd Porr <mail@berndporr.me.uk>
 * Updated: 16 Nov 2019
 * Status: stable
 */

/*
 * I must give credit here to Chris Baugher who
 * wrote the driver for AT-MIO-16d. I used some parts of this
 * driver. I also must give credits to David Brownell
 * who supported me with the USB development.
 *
 * Bernd Porr
 *
 *
 * Revision history:
 * 1.0: Fixed a rounding error in usbduxfast_ai_cmdtest
 * 0.9: Dropping the first data packet which seems to be from the last transfer.
 *      Buffer overflows in the FX2 are handed over to comedi.
 * 0.92: Dropping now 4 packets. The quad buffer has to be emptied.
 *       Added insn command basically for testing. Sample rate is
 *       1MHz/16ch=62.5kHz
 * 0.99: Ian Abbott pointed out a bug which has been corrected. Thanks!
 * 0.99a: added external trigger.
 * 1.00: added firmware kernel request to the driver which fixed
 *       udev coldplug problem
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/fcntl.h>
#include <linux/compiler.h>
#include <linux/comedi/comedi_usb.h>

/*
 * timeout for the USB-transfer
 */
#define EZTIMEOUT       30

/*
 * constants for "firmware" upload and download
 */
#define FIRMWARE                "usbduxfast_firmware.bin"
#define FIRMWARE_MAX_LEN        0x2000
#define USBDUXFASTSUB_FIRMWARE  0xA0
#define VENDOR_DIR_IN           0xC0
#define VENDOR_DIR_OUT          0x40

/*
 * internal addresses of the 8051 processor
 */
#define USBDUXFASTSUB_CPUCS     0xE600

/*
 * max length of the transfer-buffer for software upload
 */
#define TB_LEN  0x2000

/*
 * input endpoint number
 */
#define BULKINEP        6

/*
 * endpoint for the A/D channellist: bulk OUT
 */
#define CHANNELLISTEP   4

/*
 * number of channels
 */
#define NUMCHANNELS     32

/*
 * size of the waveform descriptor
 */
#define WAVESIZE        0x20

/*
 * size of one A/D value
 */
#define SIZEADIN        (sizeof(s16))

/*
 * size of the input-buffer IN BYTES
 */
#define SIZEINBUF       512

/*
 * 16 bytes
 */
#define SIZEINSNBUF     512

/*
 * size of the buffer for the dux commands in bytes
 */
#define SIZEOFDUXBUF    256

/*
 * number of in-URBs which receive the data: min=5
 */
#define NUMOFINBUFFERSHIGH      10

/*
 * min delay steps for more than one channel
 * basically when the mux gives up ;-)
 *
 * steps at 30MHz in the FX2
 */
#define MIN_SAMPLING_PERIOD     9

/*
 * max number of 1/30MHz delay steps
 */
#define MAX_SAMPLING_PERIOD     500

/*
 * number of received packets to ignore before we start handing data
 * over to comedi, it's quad buffering and we have to ignore 4 packets
 */
#define PACKETS_TO_IGNORE       4

/*
 * comedi constants
 */
static const struct comedi_lrange range_usbduxfast_ai_range = {
        2, {
                BIP_RANGE(0.75),
                BIP_RANGE(0.5)
        }
};

/*
 * private structure of one subdevice
 *
 * this is the structure which holds all the data of this driver
 * one sub device just now: A/D
 */
struct usbduxfast_private {
        struct urb *urb;        /* BULK-transfer handling: urb */
        u8 *duxbuf;
        s8 *inbuf;
        short int ai_cmd_running;       /* asynchronous command is running */
        int ignore;             /* counter which ignores the first buffers */
        struct mutex mut;
};

/*
 * bulk transfers to usbduxfast
 */
#define SENDADCOMMANDS            0
#define SENDINITEP6               1

static int usbduxfast_send_cmd(struct comedi_device *dev, int cmd_type)
{
        struct usb_device *usb = comedi_to_usb_dev(dev);
        struct usbduxfast_private *devpriv = dev->private;
        int nsent;
        int ret;

        devpriv->duxbuf[0] = cmd_type;

        ret = usb_bulk_msg(usb, usb_sndbulkpipe(usb, CHANNELLISTEP),
                           devpriv->duxbuf, SIZEOFDUXBUF,
                           &nsent, 10000);
        if (ret < 0)
                dev_err(dev->class_dev,
                        "could not transmit command to the usb-device, err=%d\n",
                        ret);
        return ret;
}

static void usbduxfast_cmd_data(struct comedi_device *dev, int index,
                                u8 len, u8 op, u8 out, u8 log)
{
        struct usbduxfast_private *devpriv = dev->private;

        /* Set the GPIF bytes, the first byte is the command byte */
        devpriv->duxbuf[1 + 0x00 + index] = len;
        devpriv->duxbuf[1 + 0x08 + index] = op;
        devpriv->duxbuf[1 + 0x10 + index] = out;
        devpriv->duxbuf[1 + 0x18 + index] = log;
}

static int usbduxfast_ai_stop(struct comedi_device *dev, int do_unlink)
{
        struct usbduxfast_private *devpriv = dev->private;

        /* stop aquistion */
        devpriv->ai_cmd_running = 0;

        if (do_unlink && devpriv->urb) {
                /* kill the running transfer */
                usb_kill_urb(devpriv->urb);
        }

        return 0;
}

static int usbduxfast_ai_cancel(struct comedi_device *dev,
                                struct comedi_subdevice *s)
{
        struct usbduxfast_private *devpriv = dev->private;
        int ret;

        mutex_lock(&devpriv->mut);
        ret = usbduxfast_ai_stop(dev, 1);
        mutex_unlock(&devpriv->mut);

        return ret;
}

static void usbduxfast_ai_handle_urb(struct comedi_device *dev,
                                     struct comedi_subdevice *s,
                                     struct urb *urb)
{
        struct usbduxfast_private *devpriv = dev->private;
        struct comedi_async *async = s->async;
        struct comedi_cmd *cmd = &async->cmd;
        int ret;

        if (devpriv->ignore) {
                devpriv->ignore--;
        } else {
                unsigned int nsamples;

                nsamples = comedi_bytes_to_samples(s, urb->actual_length);
                nsamples = comedi_nsamples_left(s, nsamples);
                comedi_buf_write_samples(s, urb->transfer_buffer, nsamples);

                if (cmd->stop_src == TRIG_COUNT &&
                    async->scans_done >= cmd->stop_arg)
                        async->events |= COMEDI_CB_EOA;
        }

        /* if command is still running, resubmit urb for BULK transfer */
        if (!(async->events & COMEDI_CB_CANCEL_MASK)) {
                urb->dev = comedi_to_usb_dev(dev);
                urb->status = 0;
                ret = usb_submit_urb(urb, GFP_ATOMIC);
                if (ret < 0) {
                        dev_err(dev->class_dev, "urb resubm failed: %d", ret);
                        async->events |= COMEDI_CB_ERROR;
                }
        }
}

static void usbduxfast_ai_interrupt(struct urb *urb)
{
        struct comedi_device *dev = urb->context;
        struct comedi_subdevice *s = dev->read_subdev;
        struct comedi_async *async = s->async;
        struct usbduxfast_private *devpriv = dev->private;

        /* exit if not running a command, do not resubmit urb */
        if (!devpriv->ai_cmd_running)
                return;

        switch (urb->status) {
        case 0:
                usbduxfast_ai_handle_urb(dev, s, urb);
                break;

        case -ECONNRESET:
        case -ENOENT:
        case -ESHUTDOWN:
        case -ECONNABORTED:
                /* after an unlink command, unplug, ... etc */
                async->events |= COMEDI_CB_ERROR;
                break;

        default:
                /* a real error */
                dev_err(dev->class_dev,
                        "non-zero urb status received in ai intr context: %d\n",
                        urb->status);
                async->events |= COMEDI_CB_ERROR;
                break;
        }

        /*
         * comedi_handle_events() cannot be used in this driver. The (*cancel)
         * operation would unlink the urb.
         */
        if (async->events & COMEDI_CB_CANCEL_MASK)
                usbduxfast_ai_stop(dev, 0);

        comedi_event(dev, s);
}

static int usbduxfast_submit_urb(struct comedi_device *dev)
{
        struct usb_device *usb = comedi_to_usb_dev(dev);
        struct usbduxfast_private *devpriv = dev->private;
        int ret;

        usb_fill_bulk_urb(devpriv->urb, usb, usb_rcvbulkpipe(usb, BULKINEP),
                          devpriv->inbuf, SIZEINBUF,
                          usbduxfast_ai_interrupt, dev);

        ret = usb_submit_urb(devpriv->urb, GFP_ATOMIC);
        if (ret) {
                dev_err(dev->class_dev, "usb_submit_urb error %d\n", ret);
                return ret;
        }
        return 0;
}

static int usbduxfast_ai_check_chanlist(struct comedi_device *dev,
                                        struct comedi_subdevice *s,
                                        struct comedi_cmd *cmd)
{
        unsigned int gain0 = CR_RANGE(cmd->chanlist[0]);
        int i;

        if (cmd->chanlist_len > 3 && cmd->chanlist_len != 16) {
                dev_err(dev->class_dev, "unsupported combination of channels\n");
                return -EINVAL;
        }

        for (i = 0; i < cmd->chanlist_len; ++i) {
                unsigned int chan = CR_CHAN(cmd->chanlist[i]);
                unsigned int gain = CR_RANGE(cmd->chanlist[i]);

                if (chan != i) {
                        dev_err(dev->class_dev,
                                "channels are not consecutive\n");
                        return -EINVAL;
                }
                if (gain != gain0 && cmd->chanlist_len > 3) {
                        dev_err(dev->class_dev,
                                "gain must be the same for all channels\n");
                        return -EINVAL;
                }
        }
        return 0;
}

static int usbduxfast_ai_cmdtest(struct comedi_device *dev,
                                 struct comedi_subdevice *s,
                                 struct comedi_cmd *cmd)
{
        int err = 0;
        int err2 = 0;
        unsigned int steps;
        unsigned int arg;

        /* Step 1 : check if triggers are trivially valid */

        err |= comedi_check_trigger_src(&cmd->start_src,
                                        TRIG_NOW | TRIG_EXT | TRIG_INT);
        err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
        err |= comedi_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
        err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
        err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);

        if (err)
                return 1;

        /* Step 2a : make sure trigger sources are unique */

        err |= comedi_check_trigger_is_unique(cmd->start_src);
        err |= comedi_check_trigger_is_unique(cmd->stop_src);

        /* Step 2b : and mutually compatible */

        if (err)
                return 2;

        /* Step 3: check if arguments are trivially valid */

        err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);

        if (!cmd->chanlist_len)
                err |= -EINVAL;

        /* external start trigger is only valid for 1 or 16 channels */
        if (cmd->start_src == TRIG_EXT &&
            cmd->chanlist_len != 1 && cmd->chanlist_len != 16)
                err |= -EINVAL;

        err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
                                           cmd->chanlist_len);

        /*
         * Validate the conversion timing:
         * for 1 channel the timing in 30MHz "steps" is:
         *      steps <= MAX_SAMPLING_PERIOD
         * for all other chanlist_len it is:
         *      MIN_SAMPLING_PERIOD <= steps <= MAX_SAMPLING_PERIOD
         */
        steps = (cmd->convert_arg * 30) / 1000;
        if (cmd->chanlist_len !=  1)
                err2 |= comedi_check_trigger_arg_min(&steps,
                                                     MIN_SAMPLING_PERIOD);
        else
                err2 |= comedi_check_trigger_arg_min(&steps, 1);
        err2 |= comedi_check_trigger_arg_max(&steps, MAX_SAMPLING_PERIOD);
        if (err2) {
                err |= err2;
                arg = (steps * 1000) / 30;
                err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
        }

        if (cmd->stop_src == TRIG_COUNT)
                err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
        else    /* TRIG_NONE */
                err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);

        if (err)
                return 3;

        /* Step 4: fix up any arguments */

        /* Step 5: check channel list if it exists */
        if (cmd->chanlist && cmd->chanlist_len > 0)
                err |= usbduxfast_ai_check_chanlist(dev, s, cmd);
        if (err)
                return 5;

        return 0;
}

static int usbduxfast_ai_inttrig(struct comedi_device *dev,
                                 struct comedi_subdevice *s,
                                 unsigned int trig_num)
{
        struct usbduxfast_private *devpriv = dev->private;
        struct comedi_cmd *cmd = &s->async->cmd;
        int ret;

        if (trig_num != cmd->start_arg)
                return -EINVAL;

        mutex_lock(&devpriv->mut);

        if (!devpriv->ai_cmd_running) {
                devpriv->ai_cmd_running = 1;
                ret = usbduxfast_submit_urb(dev);
                if (ret < 0) {
                        dev_err(dev->class_dev, "urbSubmit: err=%d\n", ret);
                        devpriv->ai_cmd_running = 0;
                        mutex_unlock(&devpriv->mut);
                        return ret;
                }
                s->async->inttrig = NULL;
        } else {
                dev_err(dev->class_dev, "ai is already running\n");
        }
        mutex_unlock(&devpriv->mut);
        return 1;
}

static int usbduxfast_ai_cmd(struct comedi_device *dev,
                             struct comedi_subdevice *s)
{
        struct usbduxfast_private *devpriv = dev->private;
        struct comedi_cmd *cmd = &s->async->cmd;
        unsigned int rngmask = 0xff;
        int j, ret;
        long steps, steps_tmp;

        mutex_lock(&devpriv->mut);
        if (devpriv->ai_cmd_running) {
                ret = -EBUSY;
                goto cmd_exit;
        }

        /*
         * ignore the first buffers from the device if there
         * is an error condition
         */
        devpriv->ignore = PACKETS_TO_IGNORE;

        steps = (cmd->convert_arg * 30) / 1000;

        switch (cmd->chanlist_len) {
        case 1:
                /*
                 * one channel
                 */

                if (CR_RANGE(cmd->chanlist[0]) > 0)
                        rngmask = 0xff - 0x04;
                else
                        rngmask = 0xff;

                /*
                 * for external trigger: looping in this state until
                 * the RDY0 pin becomes zero
                 */

                /* we loop here until ready has been set */
                if (cmd->start_src == TRIG_EXT) {
                        /* branch back to state 0 */
                        /* deceision state w/o data */
                        /* RDY0 = 0 */
                        usbduxfast_cmd_data(dev, 0, 0x01, 0x01, rngmask, 0x00);
                } else {        /* we just proceed to state 1 */
                        usbduxfast_cmd_data(dev, 0, 0x01, 0x00, rngmask, 0x00);
                }

                if (steps < MIN_SAMPLING_PERIOD) {
                        /* for fast single channel aqu without mux */
                        if (steps <= 1) {
                                /*
                                 * we just stay here at state 1 and rexecute
                                 * the same state this gives us 30MHz sampling
                                 * rate
                                 */

                                /* branch back to state 1 */
                                /* deceision state with data */
                                /* doesn't matter */
                                usbduxfast_cmd_data(dev, 1,
                                                    0x89, 0x03, rngmask, 0xff);
                        } else {
                                /*
                                 * we loop through two states: data and delay
                                 * max rate is 15MHz
                                 */
                                /* data */
                                /* doesn't matter */
                                usbduxfast_cmd_data(dev, 1, steps - 1,
                                                    0x02, rngmask, 0x00);

                                /* branch back to state 1 */
                                /* deceision state w/o data */
                                /* doesn't matter */
                                usbduxfast_cmd_data(dev, 2,
                                                    0x09, 0x01, rngmask, 0xff);
                        }
                } else {
                        /*
                         * we loop through 3 states: 2x delay and 1x data
                         * this gives a min sampling rate of 60kHz
                         */

                        /* we have 1 state with duration 1 */
                        steps = steps - 1;

                        /* do the first part of the delay */
                        usbduxfast_cmd_data(dev, 1,
                                            steps / 2, 0x00, rngmask, 0x00);

                        /* and the second part */
                        usbduxfast_cmd_data(dev, 2, steps - steps / 2,
                                            0x00, rngmask, 0x00);

                        /* get the data and branch back */

                        /* branch back to state 1 */
                        /* deceision state w data */
                        /* doesn't matter */
                        usbduxfast_cmd_data(dev, 3,
                                            0x09, 0x03, rngmask, 0xff);
                }
                break;

        case 2:
                /*
                 * two channels
                 * commit data to the FIFO
                 */

                if (CR_RANGE(cmd->chanlist[0]) > 0)
                        rngmask = 0xff - 0x04;
                else
                        rngmask = 0xff;

                /* data */
                usbduxfast_cmd_data(dev, 0, 0x01, 0x02, rngmask, 0x00);

                /* we have 1 state with duration 1: state 0 */
                steps_tmp = steps - 1;

                if (CR_RANGE(cmd->chanlist[1]) > 0)
                        rngmask = 0xff - 0x04;
                else
                        rngmask = 0xff;

                /* do the first part of the delay */
                /* count */
                usbduxfast_cmd_data(dev, 1, steps_tmp / 2,
                                    0x00, 0xfe & rngmask, 0x00);

                /* and the second part */
                usbduxfast_cmd_data(dev, 2, steps_tmp  - steps_tmp / 2,
                                    0x00, rngmask, 0x00);

                /* data */
                usbduxfast_cmd_data(dev, 3, 0x01, 0x02, rngmask, 0x00);

                /*
                 * we have 2 states with duration 1: step 6 and
                 * the IDLE state
                 */
                steps_tmp = steps - 2;

                if (CR_RANGE(cmd->chanlist[0]) > 0)
                        rngmask = 0xff - 0x04;
                else
                        rngmask = 0xff;

                /* do the first part of the delay */
                /* reset */
                usbduxfast_cmd_data(dev, 4, steps_tmp / 2,
                                    0x00, (0xff - 0x02) & rngmask, 0x00);

                /* and the second part */
                usbduxfast_cmd_data(dev, 5, steps_tmp - steps_tmp / 2,
                                    0x00, rngmask, 0x00);

                usbduxfast_cmd_data(dev, 6, 0x01, 0x00, rngmask, 0x00);
                break;

        case 3:
                /*
                 * three channels
                 */
                for (j = 0; j < 1; j++) {
                        int index = j * 2;

                        if (CR_RANGE(cmd->chanlist[j]) > 0)
                                rngmask = 0xff - 0x04;
                        else
                                rngmask = 0xff;
                        /*
                         * commit data to the FIFO and do the first part
                         * of the delay
                         */
                        /* data */
                        /* no change */
                        usbduxfast_cmd_data(dev, index, steps / 2,
                                            0x02, rngmask, 0x00);

                        if (CR_RANGE(cmd->chanlist[j + 1]) > 0)
                                rngmask = 0xff - 0x04;
                        else
                                rngmask = 0xff;

                        /* do the second part of the delay */
                        /* no data */
                        /* count */
                        usbduxfast_cmd_data(dev, index + 1, steps - steps / 2,
                                            0x00, 0xfe & rngmask, 0x00);
                }

                /* 2 steps with duration 1: the idele step and step 6: */
                steps_tmp = steps - 2;

                /* commit data to the FIFO and do the first part of the delay */
                /* data */
                usbduxfast_cmd_data(dev, 4, steps_tmp / 2,
                                    0x02, rngmask, 0x00);

                if (CR_RANGE(cmd->chanlist[0]) > 0)
                        rngmask = 0xff - 0x04;
                else
                        rngmask = 0xff;

                /* do the second part of the delay */
                /* no data */
                /* reset */
                usbduxfast_cmd_data(dev, 5, steps_tmp - steps_tmp / 2,
                                    0x00, (0xff - 0x02) & rngmask, 0x00);

                usbduxfast_cmd_data(dev, 6, 0x01, 0x00, rngmask, 0x00);
                break;

        case 16:
                if (CR_RANGE(cmd->chanlist[0]) > 0)
                        rngmask = 0xff - 0x04;
                else
                        rngmask = 0xff;

                if (cmd->start_src == TRIG_EXT) {
                        /*
                         * we loop here until ready has been set
                         */

                        /* branch back to state 0 */
                        /* deceision state w/o data */
                        /* reset */
                        /* RDY0 = 0 */
                        usbduxfast_cmd_data(dev, 0, 0x01, 0x01,
                                            (0xff - 0x02) & rngmask, 0x00);
                } else {
                        /*
                         * we just proceed to state 1
                         */

                        /* 30us reset pulse */
                        /* reset */
                        usbduxfast_cmd_data(dev, 0, 0xff, 0x00,
                                            (0xff - 0x02) & rngmask, 0x00);
                }

                /* commit data to the FIFO */
                /* data */
                usbduxfast_cmd_data(dev, 1, 0x01, 0x02, rngmask, 0x00);

                /* we have 2 states with duration 1 */
                steps = steps - 2;

                /* do the first part of the delay */
                usbduxfast_cmd_data(dev, 2, steps / 2,
                                    0x00, 0xfe & rngmask, 0x00);

                /* and the second part */
                usbduxfast_cmd_data(dev, 3, steps - steps / 2,
                                    0x00, rngmask, 0x00);

                /* branch back to state 1 */
                /* deceision state w/o data */
                /* doesn't matter */
                usbduxfast_cmd_data(dev, 4, 0x09, 0x01, rngmask, 0xff);

                break;
        }

        /* 0 means that the AD commands are sent */
        ret = usbduxfast_send_cmd(dev, SENDADCOMMANDS);
        if (ret < 0)
                goto cmd_exit;

        if ((cmd->start_src == TRIG_NOW) || (cmd->start_src == TRIG_EXT)) {
                /* enable this acquisition operation */
                devpriv->ai_cmd_running = 1;
                ret = usbduxfast_submit_urb(dev);
                if (ret < 0) {
                        devpriv->ai_cmd_running = 0;
                        /* fixme: unlink here?? */
                        goto cmd_exit;
                }
                s->async->inttrig = NULL;
        } else {        /* TRIG_INT */
                s->async->inttrig = usbduxfast_ai_inttrig;
        }

cmd_exit:
        mutex_unlock(&devpriv->mut);

        return ret;
}

/*
 * Mode 0 is used to get a single conversion on demand.
 */
static int usbduxfast_ai_insn_read(struct comedi_device *dev,
                                   struct comedi_subdevice *s,
                                   struct comedi_insn *insn,
                                   unsigned int *data)
{
        struct usb_device *usb = comedi_to_usb_dev(dev);
        struct usbduxfast_private *devpriv = dev->private;
        unsigned int chan = CR_CHAN(insn->chanspec);
        unsigned int range = CR_RANGE(insn->chanspec);
        u8 rngmask = range ? (0xff - 0x04) : 0xff;
        int i, j, n, actual_length;
        int ret;

        mutex_lock(&devpriv->mut);

        if (devpriv->ai_cmd_running) {
                dev_err(dev->class_dev,
                        "ai_insn_read not possible, async cmd is running\n");
                mutex_unlock(&devpriv->mut);
                return -EBUSY;
        }

        /* set command for the first channel */

        /* commit data to the FIFO */
        /* data */
        usbduxfast_cmd_data(dev, 0, 0x01, 0x02, rngmask, 0x00);

        /* do the first part of the delay */
        usbduxfast_cmd_data(dev, 1, 0x0c, 0x00, 0xfe & rngmask, 0x00);
        usbduxfast_cmd_data(dev, 2, 0x01, 0x00, 0xfe & rngmask, 0x00);
        usbduxfast_cmd_data(dev, 3, 0x01, 0x00, 0xfe & rngmask, 0x00);
        usbduxfast_cmd_data(dev, 4, 0x01, 0x00, 0xfe & rngmask, 0x00);

        /* second part */
        usbduxfast_cmd_data(dev, 5, 0x0c, 0x00, rngmask, 0x00);
        usbduxfast_cmd_data(dev, 6, 0x01, 0x00, rngmask, 0x00);

        ret = usbduxfast_send_cmd(dev, SENDADCOMMANDS);
        if (ret < 0) {
                mutex_unlock(&devpriv->mut);
                return ret;
        }

        for (i = 0; i < PACKETS_TO_IGNORE; i++) {
                ret = usb_bulk_msg(usb, usb_rcvbulkpipe(usb, BULKINEP),
                                   devpriv->inbuf, SIZEINBUF,
                                   &actual_length, 10000);
                if (ret < 0) {
                        dev_err(dev->class_dev, "insn timeout, no data\n");
                        mutex_unlock(&devpriv->mut);
                        return ret;
                }
        }

        for (i = 0; i < insn->n;) {
                ret = usb_bulk_msg(usb, usb_rcvbulkpipe(usb, BULKINEP),
                                   devpriv->inbuf, SIZEINBUF,
                                   &actual_length, 10000);
                if (ret < 0) {
                        dev_err(dev->class_dev, "insn data error: %d\n", ret);
                        mutex_unlock(&devpriv->mut);
                        return ret;
                }
                n = actual_length / sizeof(u16);
                if ((n % 16) != 0) {
                        dev_err(dev->class_dev, "insn data packet corrupted\n");
                        mutex_unlock(&devpriv->mut);
                        return -EINVAL;
                }
                for (j = chan; (j < n) && (i < insn->n); j = j + 16) {
                        data[i] = ((u16 *)(devpriv->inbuf))[j];
                        i++;
                }
        }

        mutex_unlock(&devpriv->mut);

        return insn->n;
}

static int usbduxfast_upload_firmware(struct comedi_device *dev,
                                      const u8 *data, size_t size,
                                      unsigned long context)
{
        struct usb_device *usb = comedi_to_usb_dev(dev);
        u8 *buf;
        unsigned char *tmp;
        int ret;

        if (!data)
                return 0;

        if (size > FIRMWARE_MAX_LEN) {
                dev_err(dev->class_dev, "firmware binary too large for FX2\n");
                return -ENOMEM;
        }

        /* we generate a local buffer for the firmware */
        buf = kmemdup(data, size, GFP_KERNEL);
        if (!buf)
                return -ENOMEM;

        /* we need a malloc'ed buffer for usb_control_msg() */
        tmp = kmalloc(1, GFP_KERNEL);
        if (!tmp) {
                kfree(buf);
                return -ENOMEM;
        }

        /* stop the current firmware on the device */
        *tmp = 1;       /* 7f92 to one */
        ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
                              USBDUXFASTSUB_FIRMWARE,
                              VENDOR_DIR_OUT,
                              USBDUXFASTSUB_CPUCS, 0x0000,
                              tmp, 1,
                              EZTIMEOUT);
        if (ret < 0) {
                dev_err(dev->class_dev, "can not stop firmware\n");
                goto done;
        }

        /* upload the new firmware to the device */
        ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
                              USBDUXFASTSUB_FIRMWARE,
                              VENDOR_DIR_OUT,
                              0, 0x0000,
                              buf, size,
                              EZTIMEOUT);
        if (ret < 0) {
                dev_err(dev->class_dev, "firmware upload failed\n");
                goto done;
        }

        /* start the new firmware on the device */
        *tmp = 0;       /* 7f92 to zero */
        ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
                              USBDUXFASTSUB_FIRMWARE,
                              VENDOR_DIR_OUT,
                              USBDUXFASTSUB_CPUCS, 0x0000,
                              tmp, 1,
                              EZTIMEOUT);
        if (ret < 0)
                dev_err(dev->class_dev, "can not start firmware\n");

done:
        kfree(tmp);
        kfree(buf);
        return ret;
}

static int usbduxfast_auto_attach(struct comedi_device *dev,
                                  unsigned long context_unused)
{
        struct usb_interface *intf = comedi_to_usb_interface(dev);
        struct usb_device *usb = comedi_to_usb_dev(dev);
        struct usbduxfast_private *devpriv;
        struct comedi_subdevice *s;
        int ret;

        if (usb->speed != USB_SPEED_HIGH) {
                dev_err(dev->class_dev,
                        "This driver needs USB 2.0 to operate. Aborting...\n");
                return -ENODEV;
        }

        devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
        if (!devpriv)
                return -ENOMEM;

        mutex_init(&devpriv->mut);
        usb_set_intfdata(intf, devpriv);

        devpriv->duxbuf = kmalloc(SIZEOFDUXBUF, GFP_KERNEL);
        if (!devpriv->duxbuf)
                return -ENOMEM;

        ret = usb_set_interface(usb,
                                intf->altsetting->desc.bInterfaceNumber, 1);
        if (ret < 0) {
                dev_err(dev->class_dev,
                        "could not switch to alternate setting 1\n");
                return -ENODEV;
        }

        devpriv->urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!devpriv->urb)
                return -ENOMEM;

        devpriv->inbuf = kmalloc(SIZEINBUF, GFP_KERNEL);
        if (!devpriv->inbuf)
                return -ENOMEM;

        ret = comedi_load_firmware(dev, &usb->dev, FIRMWARE,
                                   usbduxfast_upload_firmware, 0);
        if (ret)
                return ret;

        ret = comedi_alloc_subdevices(dev, 1);
        if (ret)
                return ret;

        /* Analog Input subdevice */
        s = &dev->subdevices[0];
        dev->read_subdev = s;
        s->type         = COMEDI_SUBD_AI;
        s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
        s->n_chan       = 16;
        s->maxdata      = 0x1000;       /* 12-bit + 1 overflow bit */
        s->range_table  = &range_usbduxfast_ai_range;
        s->insn_read    = usbduxfast_ai_insn_read;
        s->len_chanlist = s->n_chan;
        s->do_cmdtest   = usbduxfast_ai_cmdtest;
        s->do_cmd       = usbduxfast_ai_cmd;
        s->cancel       = usbduxfast_ai_cancel;

        return 0;
}

static void usbduxfast_detach(struct comedi_device *dev)
{
        struct usb_interface *intf = comedi_to_usb_interface(dev);
        struct usbduxfast_private *devpriv = dev->private;

        if (!devpriv)
                return;

        mutex_lock(&devpriv->mut);

        usb_set_intfdata(intf, NULL);

        if (devpriv->urb) {
                /* waits until a running transfer is over */
                usb_kill_urb(devpriv->urb);

                kfree(devpriv->inbuf);
                usb_free_urb(devpriv->urb);
        }

        kfree(devpriv->duxbuf);

        mutex_unlock(&devpriv->mut);

        mutex_destroy(&devpriv->mut);
}

static struct comedi_driver usbduxfast_driver = {
        .driver_name    = "usbduxfast",
        .module         = THIS_MODULE,
        .auto_attach    = usbduxfast_auto_attach,
        .detach         = usbduxfast_detach,
};

static int usbduxfast_usb_probe(struct usb_interface *intf,
                                const struct usb_device_id *id)
{
        return comedi_usb_auto_config(intf, &usbduxfast_driver, 0);
}

static const struct usb_device_id usbduxfast_usb_table[] = {
        /* { USB_DEVICE(0x4b4, 0x8613) }, testing */
        { USB_DEVICE(0x13d8, 0x0010) }, /* real ID */
        { USB_DEVICE(0x13d8, 0x0011) }, /* real ID */
        { }
};
MODULE_DEVICE_TABLE(usb, usbduxfast_usb_table);

static struct usb_driver usbduxfast_usb_driver = {
        .name           = "usbduxfast",
        .probe          = usbduxfast_usb_probe,
        .disconnect     = comedi_usb_auto_unconfig,
        .id_table       = usbduxfast_usb_table,
};
module_comedi_usb_driver(usbduxfast_driver, usbduxfast_usb_driver);

MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
MODULE_DESCRIPTION("USB-DUXfast, BerndPorr@f2s.com");
MODULE_LICENSE("GPL");
MODULE_FIRMWARE(FIRMWARE);