path: root/drivers/staging/comedi/drivers/usbduxfast.c

#define DRIVER_VERSION "v0.99a"
#define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com"
#define DRIVER_DESC "USB-DUXfast, BerndPorr@f2s.com"
/*
   comedi/drivers/usbduxfast.c
   Copyright (C) 2004 Bernd Porr, Bernd.Porr@f2s.com

   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: usbduxfast
Description: ITL USB-DUXfast
Devices: [ITL] USB-DUX (usbduxfast.o)
Author: Bernd Porr <BerndPorr@f2s.com>
Updated: 04 Dec 2006
Status: testing
*/

/*
 * 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:
 * 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.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/usb.h>
#include <linux/smp_lock.h>
#include <linux/fcntl.h>
#include <linux/compiler.h>
#include "comedi_fc.h"
#include "../comedidev.h"

// (un)comment this if you want to have debug info.
//#define CONFIG_COMEDI_DEBUG
#undef  CONFIG_COMEDI_DEBUG

#define BOARDNAME "usbduxfast"

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

// constants for "firmware" upload and download
#define USBDUXFASTSUB_FIRMWARE 0xA0
#define VENDOR_DIR_IN  0xC0
#define VENDOR_DIR_OUT 0x40

// internal adresses of the 8051 processor
#define USBDUXFASTSUB_CPUCS 0xE600

// max lenghth 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(int16_t)))

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

// 16 bytes.
#define SIZEINSNBUF       512

// Size of the buffer for the dux commands
#define SIZEOFDUXBUFFER    256	// bytes

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

// Total number of usbduxfast devices
#define NUMUSBDUXFAST             16

// Number of subdevices
#define N_SUBDEVICES          1

// Analogue in subdevice
#define SUBDEV_AD             0

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

// 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 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
typedef struct {
	// attached?
	int attached;
	// is it associated with a subdevice?
	int probed;
	// pointer to the usb-device
	struct usb_device *usbdev;
	// BULK-transfer handling: urb
	struct urb *urbIn;
	int8_t *transfer_buffer;
	// input buffer for single insn
	int16_t *insnBuffer;
	// interface number
	int ifnum;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
	// interface structure in 2.6
	struct usb_interface *interface;
#endif
	// comedi device for the interrupt context
	comedi_device *comedidev;
	// asynchronous command is running
	short int ai_cmd_running;
	// continous aquisition
	short int ai_continous;
	// number of samples to aquire
	long int ai_sample_count;
	// commands
	uint8_t *dux_commands;
	// counter which ignores the first buffers
	int ignore;
	struct semaphore sem;
} usbduxfastsub_t;

// The pointer to the private usb-data of the driver
// is also the private data for the comedi-device.
// This has to be global as the usb subsystem needs
// global variables. The other reason is that this
// structure must be there _before_ any comedi
// command is issued. The usb subsystem must be
// initialised before comedi can access it.
static usbduxfastsub_t usbduxfastsub[NUMUSBDUXFAST];

static DECLARE_MUTEX(start_stop_sem);

// bulk transfers to usbduxfast

#define SENDADCOMMANDS            0
#define SENDINITEP6               1

static int send_dux_commands(usbduxfastsub_t * this_usbduxfastsub, int cmd_type)
{
	int result, nsent;
	this_usbduxfastsub->dux_commands[0] = cmd_type;
#ifdef CONFIG_COMEDI_DEBUG
	int i;
	printk("comedi%d: usbduxfast: dux_commands: ",
		this_usbduxfastsub->comedidev->minor);
	for (i = 0; i < SIZEOFDUXBUFFER; i++) {
		printk(" %02x", this_usbduxfastsub->dux_commands[i]);
	}
	printk("\n");
#endif
	result = usb_bulk_msg(this_usbduxfastsub->usbdev,
			      usb_sndbulkpipe(this_usbduxfastsub->usbdev,
					      CHANNELLISTEP),
			      this_usbduxfastsub->dux_commands, SIZEOFDUXBUFFER,
			      &nsent, 10000);
	if (result < 0) {
		printk("comedi%d: could not transmit dux_commands to the usb-device, err=%d\n", this_usbduxfastsub->comedidev->minor, result);
	}
	return result;
}

// Stops the data acquision
// It should be safe to call this function from any context
static int usbduxfastsub_unlink_InURBs(usbduxfastsub_t * usbduxfastsub_tmp)
{
	int j = 0;
	int err = 0;

	if (usbduxfastsub_tmp && usbduxfastsub_tmp->urbIn) {
		usbduxfastsub_tmp->ai_cmd_running = 0;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8)
		j = usb_unlink_urb(usbduxfastsub_tmp->urbIn);
		if (j < 0) {
			err = j;
		}
#else
		// waits until a running transfer is over
		usb_kill_urb(usbduxfastsub_tmp->urbIn);
		j = 0;
#endif
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi: usbduxfast: unlinked InURB: res=%d\n", j);
#endif
	return err;
}

/* This will stop a running acquisition operation */
// Is called from within this driver from both the
// interrupt context and from comedi
static int usbduxfast_ai_stop(usbduxfastsub_t * this_usbduxfastsub,
	int do_unlink)
{
	int ret = 0;

	if (!this_usbduxfastsub) {
		printk("comedi?: usbduxfast_ai_stop: this_usbduxfastsub=NULL!\n");
		return -EFAULT;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi: usbduxfast_ai_stop\n");
#endif

	this_usbduxfastsub->ai_cmd_running = 0;

	if (do_unlink) {
		// stop aquistion
		ret = usbduxfastsub_unlink_InURBs(this_usbduxfastsub);
	}

	return ret;
}

// This will cancel a running acquisition operation.
// This is called by comedi but never from inside the
// driver.
static int usbduxfast_ai_cancel(comedi_device * dev, comedi_subdevice * s)
{
	usbduxfastsub_t *this_usbduxfastsub;
	int res = 0;

	// force unlink of all urbs
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi: usbduxfast_ai_cancel\n");
#endif
	this_usbduxfastsub = dev->private;
	if (!this_usbduxfastsub) {
		printk("comedi: usbduxfast_ai_cancel: this_usbduxfastsub=NULL\n");
		return -EFAULT;
	}
	down(&this_usbduxfastsub->sem);
	if (!(this_usbduxfastsub->probed)) {
		up(&this_usbduxfastsub->sem);
		return -ENODEV;
	}
	// unlink
	res = usbduxfast_ai_stop(this_usbduxfastsub, 1);
	up(&this_usbduxfastsub->sem);

	return res;
}

// analogue IN
// interrupt service routine
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
static void usbduxfastsub_ai_Irq(struct urb *urb)
#else
static void usbduxfastsub_ai_Irq(struct urb *urb PT_REGS_ARG)
#endif
{
	int n, err;
	usbduxfastsub_t *this_usbduxfastsub;
	comedi_device *this_comedidev;
	comedi_subdevice *s;
	uint16_t *p;

	// sanity checks
	// is the urb there?
	if (!urb) {
		printk("comedi_: usbduxfast_: ao int-handler called with urb=NULL!\n");
		return;
	}
	// the context variable points to the subdevice
	this_comedidev = urb->context;
	if (!this_comedidev) {
		printk("comedi_: usbduxfast_: urb context is a NULL pointer!\n");
		return;
	}
	// the private structure of the subdevice is usbduxfastsub_t
	this_usbduxfastsub = this_comedidev->private;
	if (!this_usbduxfastsub) {
		printk("comedi_: usbduxfast_: private of comedi subdev is a NULL pointer!\n");
		return;
	}
	// are we running a command?
	if (unlikely(!(this_usbduxfastsub->ai_cmd_running))) {
		// not running a command
		// do not continue execution if no asynchronous command is running
		// in particular not resubmit
		return;
	}

	if (unlikely(!(this_usbduxfastsub->attached))) {
		// no comedi device there
		return;
	}
	// subdevice which is the AD converter
	s = this_comedidev->subdevices + SUBDEV_AD;

	// first we test if something unusual has just happened
	switch (urb->status) {
	case 0:
		break;

		// happens after an unlink command or when the device is plugged out
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
	case -ECONNABORTED:
		// tell this comedi
		s->async->events |= COMEDI_CB_EOA;
		s->async->events |= COMEDI_CB_ERROR;
		comedi_event(this_usbduxfastsub->comedidev, s);
		// stop the transfer w/o unlink
		usbduxfast_ai_stop(this_usbduxfastsub, 0);
		return;

	default:
		printk("comedi%d: usbduxfast: non-zero urb status received in ai intr context: %d\n", this_usbduxfastsub->comedidev->minor, urb->status);
		s->async->events |= COMEDI_CB_EOA;
		s->async->events |= COMEDI_CB_ERROR;
		comedi_event(this_usbduxfastsub->comedidev, s);
		usbduxfast_ai_stop(this_usbduxfastsub, 0);
		return;
	}

	p = urb->transfer_buffer;
	if (!this_usbduxfastsub->ignore) {
		if (!(this_usbduxfastsub->ai_continous)) {
			// not continous, fixed number of samples
			n = urb->actual_length / sizeof(uint16_t);
			if (unlikely(this_usbduxfastsub->ai_sample_count < n)) {
				// we have send only a fraction of the bytes received
				cfc_write_array_to_buffer(s,
					urb->transfer_buffer,
					this_usbduxfastsub->ai_sample_count *
					sizeof(uint16_t));
				usbduxfast_ai_stop(this_usbduxfastsub, 0);
				// say comedi that the acquistion is over
				s->async->events |= COMEDI_CB_EOA;
				comedi_event(this_usbduxfastsub->comedidev, s);
				return;
			}
			this_usbduxfastsub->ai_sample_count -= n;
		}
		// write the full buffer to comedi
		cfc_write_array_to_buffer(s,
			urb->transfer_buffer, urb->actual_length);

		// tell comedi that data is there
		comedi_event(this_usbduxfastsub->comedidev, s);

	} else {
		// ignore this packet
		this_usbduxfastsub->ignore--;
	}

	// command is still running
	// resubmit urb for BULK transfer
	urb->dev = this_usbduxfastsub->usbdev;
	urb->status = 0;
	err = usb_submit_urb(urb, GFP_ATOMIC);
	if (err < 0) {
		printk("comedi%d: usbduxfast: urb resubm failed: %d",
			this_usbduxfastsub->comedidev->minor, err);
		s->async->events |= COMEDI_CB_EOA;
		s->async->events |= COMEDI_CB_ERROR;
		comedi_event(this_usbduxfastsub->comedidev, s);
		usbduxfast_ai_stop(this_usbduxfastsub, 0);
	}
}

static int usbduxfastsub_start(usbduxfastsub_t * usbduxfastsub)
{
	int errcode = 0;
	unsigned char local_transfer_buffer[16];

	if (usbduxfastsub->probed) {
		// 7f92 to zero
		local_transfer_buffer[0] = 0;
		errcode = usb_control_msg(usbduxfastsub->usbdev,
			// create a pipe for a control transfer
			usb_sndctrlpipe(usbduxfastsub->usbdev, 0),
			// bRequest, "Firmware"
			USBDUXFASTSUB_FIRMWARE,
			// bmRequestType
			VENDOR_DIR_OUT,
			// Value
			USBDUXFASTSUB_CPUCS,
			// Index
			0x0000,
			// address of the transfer buffer
			local_transfer_buffer,
			// Length
			1,
			// Timeout
			EZTIMEOUT);
		if (errcode < 0) {
			printk("comedi_: usbduxfast_: control msg failed (start)\n");
			return errcode;
		}
	}
	return 0;
}

static int usbduxfastsub_stop(usbduxfastsub_t * usbduxfastsub)
{
	int errcode = 0;

	unsigned char local_transfer_buffer[16];
	if (usbduxfastsub->probed) {
		// 7f92 to one
		local_transfer_buffer[0] = 1;
		errcode = usb_control_msg(usbduxfastsub->usbdev,
			usb_sndctrlpipe(usbduxfastsub->usbdev, 0),
			// bRequest, "Firmware"
			USBDUXFASTSUB_FIRMWARE,
			// bmRequestType
			VENDOR_DIR_OUT,
			// Value
			USBDUXFASTSUB_CPUCS,
			// Index
			0x0000, local_transfer_buffer,
			// Length
			1,
			// Timeout
			EZTIMEOUT);
		if (errcode < 0) {
			printk("comedi_: usbduxfast: control msg failed (stop)\n");
			return errcode;
		}
	}
	return 0;
}

static int usbduxfastsub_upload(usbduxfastsub_t * usbduxfastsub,
	unsigned char *local_transfer_buffer,
	unsigned int startAddr, unsigned int len)
{
	int errcode;

	if (usbduxfastsub->probed) {
#ifdef CONFIG_COMEDI_DEBUG
		printk("comedi%d: usbduxfast: uploading %d bytes",
			usbduxfastsub->comedidev->minor, len);
		printk(" to addr %d, first byte=%d.\n",
			startAddr, local_transfer_buffer[0]);
#endif
		errcode = usb_control_msg(usbduxfastsub->usbdev,
			usb_sndctrlpipe(usbduxfastsub->usbdev, 0),
			// brequest, firmware
			USBDUXFASTSUB_FIRMWARE,
			// bmRequestType
			VENDOR_DIR_OUT,
			// value
			startAddr,
			// index
			0x0000,
			// our local safe buffer
			local_transfer_buffer,
			// length
			len,
			// timeout
			EZTIMEOUT);
#ifdef CONFIG_COMEDI_DEBUG
		printk("comedi_: usbduxfast: result=%d\n", errcode);
#endif
		if (errcode < 0) {
			printk("comedi_: usbduxfast: uppload failed\n");
			return errcode;
		}
	} else {
		// no device on the bus for this index
		return -EFAULT;
	}
	return 0;
}

int firmwareUpload(usbduxfastsub_t * usbduxfastsub,
	unsigned char *firmwareBinary, int sizeFirmware)
{
	int ret;

	if (!firmwareBinary) {
		return 0;
	}
	ret = usbduxfastsub_stop(usbduxfastsub);
	if (ret < 0) {
		printk("comedi_: usbduxfast: can not stop firmware\n");
		return ret;
	}
	ret = usbduxfastsub_upload(usbduxfastsub,
		firmwareBinary, 0, sizeFirmware);
	if (ret < 0) {
		printk("comedi_: usbduxfast: firmware upload failed\n");
		return ret;
	}
	ret = usbduxfastsub_start(usbduxfastsub);
	if (ret < 0) {
		printk("comedi_: usbduxfast: can not start firmware\n");
		return ret;
	}
	return 0;
}

int usbduxfastsub_submit_InURBs(usbduxfastsub_t * usbduxfastsub)
{
	int errFlag;

	if (!usbduxfastsub) {
		return -EFAULT;
	}
	usb_fill_bulk_urb(usbduxfastsub->urbIn,
		usbduxfastsub->usbdev,
		usb_rcvbulkpipe(usbduxfastsub->usbdev, BULKINEP),
		usbduxfastsub->transfer_buffer,
		SIZEINBUF, usbduxfastsub_ai_Irq, usbduxfastsub->comedidev);

#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast: submitting in-urb: %x,%x\n",
		usbduxfastsub->comedidev->minor,
		(int)(usbduxfastsub->urbIn->context),
		(int)(usbduxfastsub->urbIn->dev));
#endif
	errFlag = usb_submit_urb(usbduxfastsub->urbIn, GFP_ATOMIC);
	if (errFlag) {
		printk("comedi_: usbduxfast: ai: usb_submit_urb error %d\n",
			errFlag);
		return errFlag;
	}
	return 0;
}

static int usbduxfast_ai_cmdtest(comedi_device * dev,
	comedi_subdevice * s, comedi_cmd * cmd)
{
	int err = 0, stop_mask = 0;
	long int steps, tmp = 0;
	int minSamplPer;
	usbduxfastsub_t *this_usbduxfastsub = dev->private;
	if (!(this_usbduxfastsub->probed)) {
		return -ENODEV;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast_ai_cmdtest\n", dev->minor);
	printk("comedi%d: usbduxfast: convert_arg=%u scan_begin_arg=%u\n",
		dev->minor, cmd->convert_arg, cmd->scan_begin_arg);
#endif
	/* step 1: make sure trigger sources are trivially valid */

	tmp = cmd->start_src;
	cmd->start_src &= TRIG_NOW | TRIG_EXT | TRIG_INT;
	if (!cmd->start_src || tmp != cmd->start_src)
		err++;

	tmp = cmd->scan_begin_src;
	cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW | TRIG_EXT;
	if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
		err++;

	tmp = cmd->convert_src;
	cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
	if (!cmd->convert_src || tmp != cmd->convert_src)
		err++;

	tmp = cmd->scan_end_src;
	cmd->scan_end_src &= TRIG_COUNT;
	if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
		err++;

	tmp = cmd->stop_src;
	stop_mask = TRIG_COUNT | TRIG_NONE;
	cmd->stop_src &= stop_mask;
	if (!cmd->stop_src || tmp != cmd->stop_src)
		err++;

	if (err)
		return 1;

	/* step 2: make sure trigger sources are unique and mutually compatible */

	if (cmd->start_src != TRIG_NOW &&
		cmd->start_src != TRIG_EXT && cmd->start_src != TRIG_INT)
		err++;
	if (cmd->scan_begin_src != TRIG_TIMER &&
		cmd->scan_begin_src != TRIG_FOLLOW &&
		cmd->scan_begin_src != TRIG_EXT)
		err++;
	if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
		err++;
	if (cmd->stop_src != TRIG_COUNT &&
		cmd->stop_src != TRIG_EXT && cmd->stop_src != TRIG_NONE)
		err++;

	// can't have external stop and start triggers at once
	if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT)
		err++;

	if (err)
		return 2;

	/* step 3: make sure arguments are trivially compatible */

	if (cmd->start_src == TRIG_NOW && cmd->start_arg != 0) {
		cmd->start_arg = 0;
		err++;
	}

	if (!cmd->chanlist_len) {
		err++;
	}
	if (cmd->scan_end_arg != cmd->chanlist_len) {
		cmd->scan_end_arg = cmd->chanlist_len;
		err++;
	}

	if (cmd->chanlist_len == 1) {
		minSamplPer = 1;
	} else {
		minSamplPer = MIN_SAMPLING_PERIOD;
	}

	if (cmd->convert_src == TRIG_TIMER) {
		steps = cmd->convert_arg * 30;
		if (steps < (minSamplPer * 1000)) {
			steps = minSamplPer * 1000;
		}
		if (steps > (MAX_SAMPLING_PERIOD * 1000)) {
			steps = MAX_SAMPLING_PERIOD * 1000;
		}
		// calc arg again
		tmp = steps / 30;
		if (cmd->convert_arg != tmp) {
			cmd->convert_arg = tmp;
			err++;
		}
	}

	if (cmd->scan_begin_src == TRIG_TIMER) {
		err++;
	}
	// stop source
	switch (cmd->stop_src) {
	case TRIG_COUNT:
		if (!cmd->stop_arg) {
			cmd->stop_arg = 1;
			err++;
		}
		break;
	case TRIG_NONE:
		if (cmd->stop_arg != 0) {
			cmd->stop_arg = 0;
			err++;
		}
		break;
		// TRIG_EXT doesn't care since it doesn't trigger off a numbered channel
	default:
		break;
	}

	if (err)
		return 3;

	/* step 4: fix up any arguments */

	return 0;

}

static int usbduxfast_ai_inttrig(comedi_device * dev,
	comedi_subdevice * s, unsigned int trignum)
{
	int ret;
	usbduxfastsub_t *this_usbduxfastsub = dev->private;
	if (!this_usbduxfastsub) {
		return -EFAULT;
	}
	down(&this_usbduxfastsub->sem);
	if (!(this_usbduxfastsub->probed)) {
		up(&this_usbduxfastsub->sem);
		return -ENODEV;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast_ai_inttrig\n", dev->minor);
#endif

	if (trignum != 0) {
		printk("comedi%d: usbduxfast_ai_inttrig: invalid trignum\n",
			dev->minor);
		up(&this_usbduxfastsub->sem);
		return -EINVAL;
	}
	if (!(this_usbduxfastsub->ai_cmd_running)) {
		this_usbduxfastsub->ai_cmd_running = 1;
		ret = usbduxfastsub_submit_InURBs(this_usbduxfastsub);
		if (ret < 0) {
			printk("comedi%d: usbduxfast_ai_inttrig: urbSubmit: err=%d\n", dev->minor, ret);
			this_usbduxfastsub->ai_cmd_running = 0;
			up(&this_usbduxfastsub->sem);
			return ret;
		}
		s->async->inttrig = NULL;
	} else {
		printk("comedi%d: ai_inttrig but acqu is already running\n",
			dev->minor);
	}
	up(&this_usbduxfastsub->sem);
	return 1;
}

// offsets for the GPIF bytes
// the first byte is the command byte
#define LENBASE 1+0x00
#define OPBASE  1+0x08
#define OUTBASE 1+0x10
#define LOGBASE 1+0x18

static int usbduxfast_ai_cmd(comedi_device * dev, comedi_subdevice * s)
{
	comedi_cmd *cmd = &s->async->cmd;
	unsigned int chan, gain, rngmask = 0xff;
	int i, j, ret;
	usbduxfastsub_t *this_usbduxfastsub = dev->private;
	int result;
	long steps, steps_tmp;

#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast_ai_cmd\n", dev->minor);
#endif
	if (!this_usbduxfastsub) {
		return -EFAULT;
	}
	down(&this_usbduxfastsub->sem);
	if (!(this_usbduxfastsub->probed)) {
		up(&this_usbduxfastsub->sem);
		return -ENODEV;
	}
	if (this_usbduxfastsub->ai_cmd_running) {
		printk("comedi%d: ai_cmd not possible. Another ai_cmd is running.\n", dev->minor);
		up(&this_usbduxfastsub->sem);
		return -EBUSY;
	}
	// set current channel of the running aquisition to zero
	s->async->cur_chan = 0;

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

	if (cmd->chanlist_len > 0) {
		gain = CR_RANGE(cmd->chanlist[0]);
		for (i = 0; i < cmd->chanlist_len; ++i) {
			chan = CR_CHAN(cmd->chanlist[i]);
			if (chan != i) {
				printk("comedi%d: cmd is accepting only consecutive channels.\n", dev->minor);
				up(&this_usbduxfastsub->sem);
				return -EINVAL;
			}
			if ((gain != CR_RANGE(cmd->chanlist[i]))
				&& (cmd->chanlist_len > 3)) {
				printk("comedi%d: the gain must be the same for all channels.\n", dev->minor);
				up(&this_usbduxfastsub->sem);
				return -EINVAL;
			}
			if (i >= NUMCHANNELS) {
				printk("comedi%d: channel list too long\n",
					dev->minor);
				break;
			}
		}
	}
	steps = 0;
	if (cmd->scan_begin_src == TRIG_TIMER) {
		printk("comedi%d: usbduxfast: scan_begin_src==TRIG_TIMER not valid.\n", dev->minor);
		up(&this_usbduxfastsub->sem);
		return -EINVAL;
	}
	if (cmd->convert_src == TRIG_TIMER) {
		steps = (cmd->convert_arg * 30) / 1000;
	}
	if ((steps < MIN_SAMPLING_PERIOD) && (cmd->chanlist_len != 1)) {
		printk("comedi%d: usbduxfast: ai_cmd: steps=%ld, scan_begin_arg=%d. Not properly tested by cmdtest?\n", dev->minor, steps, cmd->scan_begin_arg);
		up(&this_usbduxfastsub->sem);
		return -EINVAL;
	}
	if (steps > MAX_SAMPLING_PERIOD) {
		printk("comedi%d: usbduxfast: ai_cmd: sampling rate too low.\n",
			dev->minor);
		up(&this_usbduxfastsub->sem);
		return -EINVAL;
	}
	if ((cmd->start_src == TRIG_EXT) && (cmd->chanlist_len != 1)
		&& (cmd->chanlist_len != 16)) {
		printk("comedi%d: usbduxfast: ai_cmd: TRIG_EXT only with 1 or 16 channels possible.\n", dev->minor);
		up(&this_usbduxfastsub->sem);
		return -EINVAL;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast: steps=%ld, convert_arg=%u, ai_timer=%u\n",
		dev->minor,
		steps, cmd->convert_arg, this_usbduxfastsub->ai_timer);
#endif

	switch (cmd->chanlist_len) {
		// one channel
	case 1:
		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
		if (cmd->start_src == TRIG_EXT) {	// we loop here until ready has been set
			this_usbduxfastsub->dux_commands[LENBASE + 0] = 0x01;	// branch back to state 0
			this_usbduxfastsub->dux_commands[OPBASE + 0] = 0x01;	// deceision state w/o data
			this_usbduxfastsub->dux_commands[OUTBASE + 0] =
				0xFF & rngmask;
			this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0x00;	// RDY0 = 0
		} else {	// we just proceed to state 1
			this_usbduxfastsub->dux_commands[LENBASE + 0] = 1;
			this_usbduxfastsub->dux_commands[OPBASE + 0] = 0;
			this_usbduxfastsub->dux_commands[OUTBASE + 0] =
				0xFF & rngmask;
			this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0;
		}

		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
				this_usbduxfastsub->dux_commands[LENBASE + 1] = 0x89;	// branch back to state 1
				this_usbduxfastsub->dux_commands[OPBASE + 1] = 0x03;	// deceision state with data
				this_usbduxfastsub->dux_commands[OUTBASE + 1] =
					0xFF & rngmask;
				this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0xFF;	// doesn't matter
			} else {
				// we loop through two states: data and delay: max rate is 15Mhz
				this_usbduxfastsub->dux_commands[LENBASE + 1] =
					steps - 1;
				this_usbduxfastsub->dux_commands[OPBASE + 1] = 0x02;	// data
				this_usbduxfastsub->dux_commands[OUTBASE + 1] =
					0xFF & rngmask;
				this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0;	// doesn't matter

				this_usbduxfastsub->dux_commands[LENBASE + 2] = 0x09;	// branch back to state 1
				this_usbduxfastsub->dux_commands[OPBASE + 2] = 0x01;	// deceision state w/o data
				this_usbduxfastsub->dux_commands[OUTBASE + 2] =
					0xFF & rngmask;
				this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0xFF;	// doesn't matter
			}
		} 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
			this_usbduxfastsub->dux_commands[LENBASE + 1] =
				steps / 2;
			this_usbduxfastsub->dux_commands[OPBASE + 1] = 0;
			this_usbduxfastsub->dux_commands[OUTBASE + 1] =
				0xFF & rngmask;
			this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0;

			// and the second part
			this_usbduxfastsub->dux_commands[LENBASE + 2] =
				steps - steps / 2;
			this_usbduxfastsub->dux_commands[OPBASE + 2] = 0;
			this_usbduxfastsub->dux_commands[OUTBASE + 2] =
				0xFF & rngmask;
			this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0;

			// get the data and branch back
			this_usbduxfastsub->dux_commands[LENBASE + 3] = 0x09;	// branch back to state 1
			this_usbduxfastsub->dux_commands[OPBASE + 3] = 0x03;	// deceision state w data
			this_usbduxfastsub->dux_commands[OUTBASE + 3] =
				0xFF & rngmask;
			this_usbduxfastsub->dux_commands[LOGBASE + 3] = 0xFF;	// doesn't matter
		}
		break;

	case 2:
		// two channels
		// commit data to the FIFO
		if (CR_RANGE(cmd->chanlist[0]) > 0)
			rngmask = 0xff - 0x04;
		else
			rngmask = 0xff;
		this_usbduxfastsub->dux_commands[LENBASE + 0] = 1;
		this_usbduxfastsub->dux_commands[OPBASE + 0] = 0x02;	// data
		this_usbduxfastsub->dux_commands[OUTBASE + 0] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0;

		// 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
		this_usbduxfastsub->dux_commands[LENBASE + 1] = steps_tmp / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 1] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 1] = 0xFE & rngmask;	//count
		this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0;

		// and the second part
		this_usbduxfastsub->dux_commands[LENBASE + 2] =
			steps_tmp - steps_tmp / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 2] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 2] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0;

		this_usbduxfastsub->dux_commands[LENBASE + 3] = 1;
		this_usbduxfastsub->dux_commands[OPBASE + 3] = 0x02;	// data
		this_usbduxfastsub->dux_commands[OUTBASE + 3] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 3] = 0;

		// 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
		this_usbduxfastsub->dux_commands[LENBASE + 4] = steps_tmp / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 4] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 4] = (0xFF - 0x02) & rngmask;	//reset
		this_usbduxfastsub->dux_commands[LOGBASE + 4] = 0;

		// and the second part
		this_usbduxfastsub->dux_commands[LENBASE + 5] =
			steps_tmp - steps_tmp / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 5] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 5] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 5] = 0;

		this_usbduxfastsub->dux_commands[LENBASE + 6] = 1;
		this_usbduxfastsub->dux_commands[OPBASE + 6] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 6] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 6] = 0;
		break;

	case 3:
		// three channels
		for (j = 0; j < 1; j++) {
			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
			this_usbduxfastsub->dux_commands[LENBASE + j * 2] =
				steps / 2;
			this_usbduxfastsub->dux_commands[OPBASE + j * 2] = 0x02;	// data
			this_usbduxfastsub->dux_commands[OUTBASE + j * 2] = 0xFF & rngmask;	// no change
			this_usbduxfastsub->dux_commands[LOGBASE + j * 2] = 0;

			if (CR_RANGE(cmd->chanlist[j + 1]) > 0)
				rngmask = 0xff - 0x04;
			else
				rngmask = 0xff;
			// do the second part of the delay
			this_usbduxfastsub->dux_commands[LENBASE + j * 2 + 1] =
				steps - steps / 2;
			this_usbduxfastsub->dux_commands[OPBASE + j * 2 + 1] = 0;	// no data
			this_usbduxfastsub->dux_commands[OUTBASE + j * 2 + 1] = 0xFE & rngmask;	//count
			this_usbduxfastsub->dux_commands[LOGBASE + j * 2 + 1] =
				0;
		}

		// 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
		this_usbduxfastsub->dux_commands[LENBASE + 4] = steps_tmp / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 4] = 0x02;	// data
		this_usbduxfastsub->dux_commands[OUTBASE + 4] = 0xFF & rngmask;	// no change
		this_usbduxfastsub->dux_commands[LOGBASE + 4] = 0;

		if (CR_RANGE(cmd->chanlist[0]) > 0)
			rngmask = 0xff - 0x04;
		else
			rngmask = 0xff;
		// do the second part of the delay
		this_usbduxfastsub->dux_commands[LENBASE + 5] =
			steps_tmp - steps_tmp / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 5] = 0;	// no data
		this_usbduxfastsub->dux_commands[OUTBASE + 5] = (0xFF - 0x02) & rngmask;	// reset
		this_usbduxfastsub->dux_commands[LOGBASE + 5] = 0;

		this_usbduxfastsub->dux_commands[LENBASE + 6] = 1;
		this_usbduxfastsub->dux_commands[OPBASE + 6] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 6] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 6] = 0;

	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
			this_usbduxfastsub->dux_commands[LENBASE + 0] = 0x01;	// branch back to state 0
			this_usbduxfastsub->dux_commands[OPBASE + 0] = 0x01;	// deceision state w/o data
			this_usbduxfastsub->dux_commands[OUTBASE + 0] = (0xFF - 0x02) & rngmask;	// reset
			this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0x00;	// RDY0 = 0
		} else {	// we just proceed to state 1
			this_usbduxfastsub->dux_commands[LENBASE + 0] = 255;	// 30us reset pulse
			this_usbduxfastsub->dux_commands[OPBASE + 0] = 0;
			this_usbduxfastsub->dux_commands[OUTBASE + 0] = (0xFF - 0x02) & rngmask;	// reset
			this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0;
		}

		// commit data to the FIFO
		this_usbduxfastsub->dux_commands[LENBASE + 1] = 1;
		this_usbduxfastsub->dux_commands[OPBASE + 1] = 0x02;	// data
		this_usbduxfastsub->dux_commands[OUTBASE + 1] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0;

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

		// do the first part of the delay
		this_usbduxfastsub->dux_commands[LENBASE + 2] = steps / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 2] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 2] = 0xFE & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0;

		// and the second part
		this_usbduxfastsub->dux_commands[LENBASE + 3] =
			steps - steps / 2;
		this_usbduxfastsub->dux_commands[OPBASE + 3] = 0;
		this_usbduxfastsub->dux_commands[OUTBASE + 3] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 3] = 0;

		this_usbduxfastsub->dux_commands[LENBASE + 4] = 0x09;	// branch back to state 1
		this_usbduxfastsub->dux_commands[OPBASE + 4] = 0x01;	// deceision state w/o data
		this_usbduxfastsub->dux_commands[OUTBASE + 4] = 0xFF & rngmask;
		this_usbduxfastsub->dux_commands[LOGBASE + 4] = 0xFF;	// doesn't matter

		break;

	default:
		printk("comedi %d: unsupported combination of channels\n",
			dev->minor);
		up(&this_usbduxfastsub->sem);
		return -EFAULT;
	}

#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi %d: sending commands to the usb device\n", dev->minor);
#endif
	// 0 means that the AD commands are sent
	result = send_dux_commands(this_usbduxfastsub, SENDADCOMMANDS);
	if (result < 0) {
		printk("comedi%d: adc command could not be submitted. Aborting...\n", dev->minor);
		up(&this_usbduxfastsub->sem);
		return result;
	}
	if (cmd->stop_src == TRIG_COUNT) {
		this_usbduxfastsub->ai_sample_count =
			(cmd->stop_arg) * (cmd->scan_end_arg);
		if (usbduxfastsub->ai_sample_count < 1) {
			printk("comedi%d: (cmd->stop_arg)*(cmd->scan_end_arg)<1, aborting.\n", dev->minor);
			up(&this_usbduxfastsub->sem);
			return -EFAULT;
		}
		this_usbduxfastsub->ai_continous = 0;
	} else {
		// continous aquisition
		this_usbduxfastsub->ai_continous = 1;
		this_usbduxfastsub->ai_sample_count = 0;
	}

	if ((cmd->start_src == TRIG_NOW) || (cmd->start_src == TRIG_EXT)) {
		// enable this acquisition operation
		this_usbduxfastsub->ai_cmd_running = 1;
		ret = usbduxfastsub_submit_InURBs(this_usbduxfastsub);
		if (ret < 0) {
			this_usbduxfastsub->ai_cmd_running = 0;
			// fixme: unlink here??
			up(&this_usbduxfastsub->sem);
			return ret;
		}
		s->async->inttrig = NULL;
	} else {
		/* TRIG_INT */
		// don't enable the acquision operation
		// wait for an internal signal
		s->async->inttrig = usbduxfast_ai_inttrig;
	}
	up(&this_usbduxfastsub->sem);

	return 0;
}

/* Mode 0 is used to get a single conversion on demand */
static int usbduxfast_ai_insn_read(comedi_device * dev,
	comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
{
	int i, j, n, actual_length;
	int chan, range, rngmask;
	int err;
	usbduxfastsub_t *usbduxfastsub = dev->private;

	if (!usbduxfastsub) {
		printk("comedi%d: ai_insn_read: no usb dev.\n", dev->minor);
		return -ENODEV;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: ai_insn_read, insn->n=%d, insn->subdev=%d\n",
		dev->minor, insn->n, insn->subdev);
#endif
	down(&usbduxfastsub->sem);
	if (!(usbduxfastsub->probed)) {
		up(&usbduxfastsub->sem);
		return -ENODEV;
	}
	if (usbduxfastsub->ai_cmd_running) {
		printk("comedi%d: ai_insn_read not possible. Async Command is running.\n", dev->minor);
		up(&usbduxfastsub->sem);
		return -EBUSY;
	}
	// sample one channel
	chan = CR_CHAN(insn->chanspec);
	range = CR_RANGE(insn->chanspec);
	// set command for the first channel

	if (range > 0)
		rngmask = 0xff - 0x04;
	else
		rngmask = 0xff;
	// commit data to the FIFO
	usbduxfastsub->dux_commands[LENBASE + 0] = 1;
	usbduxfastsub->dux_commands[OPBASE + 0] = 0x02;	// data
	usbduxfastsub->dux_commands[OUTBASE + 0] = 0xFF & rngmask;
	usbduxfastsub->dux_commands[LOGBASE + 0] = 0;

	// do the first part of the delay
	usbduxfastsub->dux_commands[LENBASE + 1] = 12;
	usbduxfastsub->dux_commands[OPBASE + 1] = 0;
	usbduxfastsub->dux_commands[OUTBASE + 1] = 0xFE & rngmask;
	usbduxfastsub->dux_commands[LOGBASE + 1] = 0;

	usbduxfastsub->dux_commands[LENBASE + 2] = 1;
	usbduxfastsub->dux_commands[OPBASE + 2] = 0;
	usbduxfastsub->dux_commands[OUTBASE + 2] = 0xFE & rngmask;
	usbduxfastsub->dux_commands[LOGBASE + 2] = 0;

	usbduxfastsub->dux_commands[LENBASE + 3] = 1;
	usbduxfastsub->dux_commands[OPBASE + 3] = 0;
	usbduxfastsub->dux_commands[OUTBASE + 3] = 0xFE & rngmask;
	usbduxfastsub->dux_commands[LOGBASE + 3] = 0;

	usbduxfastsub->dux_commands[LENBASE + 4] = 1;
	usbduxfastsub->dux_commands[OPBASE + 4] = 0;
	usbduxfastsub->dux_commands[OUTBASE + 4] = 0xFE & rngmask;
	usbduxfastsub->dux_commands[LOGBASE + 4] = 0;

	// second part
	usbduxfastsub->dux_commands[LENBASE + 5] = 12;
	usbduxfastsub->dux_commands[OPBASE + 5] = 0;
	usbduxfastsub->dux_commands[OUTBASE + 5] = 0xFF & rngmask;
	usbduxfastsub->dux_commands[LOGBASE + 5] = 0;

	usbduxfastsub->dux_commands[LENBASE + 6] = 1;
	usbduxfastsub->dux_commands[OPBASE + 6] = 0;
	usbduxfastsub->dux_commands[OUTBASE + 6] = 0xFF & rngmask;
	usbduxfastsub->dux_commands[LOGBASE + 0] = 0;

#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi %d: sending commands to the usb device\n", dev->minor);
#endif
	// 0 means that the AD commands are sent
	err = send_dux_commands(usbduxfastsub, SENDADCOMMANDS);
	if (err < 0) {
		printk("comedi%d: adc command could not be submitted. Aborting...\n", dev->minor);
		up(&usbduxfastsub->sem);
		return err;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast: submitting in-urb: %x,%x\n",
		usbduxfastsub->comedidev->minor,
		(int)(usbduxfastsub->urbIn->context),
		(int)(usbduxfastsub->urbIn->dev));
#endif
	for (i = 0; i < PACKETS_TO_IGNORE; i++) {
		err = usb_bulk_msg(usbduxfastsub->usbdev,
				   usb_rcvbulkpipe(usbduxfastsub->usbdev,
						   BULKINEP),
				   usbduxfastsub->transfer_buffer, SIZEINBUF,
				   &actual_length, 10000);
		if (err < 0) {
			printk("comedi%d: insn timeout. No data.\n",
				dev->minor);
			up(&usbduxfastsub->sem);
			return err;
		}
	}
	// data points
	for (i = 0; i < insn->n;) {
		err = usb_bulk_msg(usbduxfastsub->usbdev,
				   usb_rcvbulkpipe(usbduxfastsub->usbdev,
						   BULKINEP),
				   usbduxfastsub->transfer_buffer, SIZEINBUF,
				   &actual_length, 10000);
		if (err < 0) {
			printk("comedi%d: insn data error: %d\n",
				dev->minor, err);
			up(&usbduxfastsub->sem);
			return err;
		}
		n = actual_length / sizeof(uint16_t);
		if ((n % 16) != 0) {
			printk("comedi%d: insn data packet corrupted.\n",
				dev->minor);
			up(&usbduxfastsub->sem);
			return -EINVAL;
		}
		for (j = chan; (j < n) && (i < insn->n); j = j + 16) {
			data[i] =
				((uint16_t *) (usbduxfastsub->
					transfer_buffer))[j];
			i++;
		}
	}
	up(&usbduxfastsub->sem);
	return i;
}

static unsigned hex2unsigned(char *h)
{
	unsigned hi, lo;
	if (h[0] > '9') {
		hi = h[0] - 'A' + 0x0a;
	} else {
		hi = h[0] - '0';
	}
	if (h[1] > '9') {
		lo = h[1] - 'A' + 0x0a;
	} else {
		lo = h[1] - '0';
	}
	return hi * 0x10 + lo;
}

// for FX2
#define FIRMWARE_MAX_LEN 0x2000

// taken from David Brownell's fxload and adjusted for this driver
static int read_firmware(usbduxfastsub_t * usbduxfastsub, void *firmwarePtr,
	long size)
{
	int i = 0;
	unsigned char *fp = (char *)firmwarePtr;
	unsigned char *firmwareBinary = NULL;
	int res = 0;
	int maxAddr = 0;

	firmwareBinary = kmalloc(FIRMWARE_MAX_LEN, GFP_KERNEL);
	if (!firmwareBinary) {
		printk("comedi_: usbduxfast: mem alloc for firmware failed\n");
		return -ENOMEM;
	}

	for (;;) {
		char buf[256], *cp;
		char type;
		int len;
		int idx, off;
		int j = 0;

		// get one line
		while ((i < size) && (fp[i] != 13) && (fp[i] != 10)) {
			buf[j] = fp[i];
			i++;
			j++;
			if (j >= sizeof(buf)) {
				printk("comedi_: usbduxfast: bogus firmware file!\n");
				return -1;
			}
		}
		// get rid of LF/CR/...
		while ((i < size) && ((fp[i] == 13) || (fp[i] == 10)
				|| (fp[i] == 0))) {
			i++;
		}

		buf[j] = 0;
		//printk("comedi_: buf=%s\n",buf);

		/* EXTENSION: "# comment-till-end-of-line", for copyrights etc */
		if (buf[0] == '#')
			continue;

		if (buf[0] != ':') {
			printk("comedi_: usbduxfast: upload: not an ihex record: %s", buf);
			return -EFAULT;
		}

		/* Read the length field (up to 16 bytes) */
		len = hex2unsigned(buf + 1);

		/* Read the target offset */
		off = (hex2unsigned(buf + 3) * 0x0100) + hex2unsigned(buf + 5);

		if ((off + len) > maxAddr) {
			maxAddr = off + len;
		}

		if (maxAddr >= FIRMWARE_MAX_LEN) {
			printk("comedi_: usbduxfast: firmware upload goes beyond FX2 RAM boundaries.");
			return -EFAULT;
		}
		//printk("comedi_: usbduxfast: off=%x, len=%x:",off,len);

		/* Read the record type */
		type = hex2unsigned(buf + 7);

		/* If this is an EOF record, then make it so. */
		if (type == 1) {
			break;
		}

		if (type != 0) {
			printk("comedi_: usbduxfast: unsupported record type: %u\n", type);
			return -EFAULT;
		}

		for (idx = 0, cp = buf + 9; idx < len; idx += 1, cp += 2) {
			firmwareBinary[idx + off] = hex2unsigned(cp);
			//printk("%02x ",firmwareBinary[idx+off]);
		}
		//printk("\n");

		if (i >= size) {
			printk("comedi_: usbduxfast: unexpected end of hex file\n");
			break;
		}

	}
	res = firmwareUpload(usbduxfastsub, firmwareBinary, maxAddr + 1);
	kfree(firmwareBinary);
	return res;
}

static void tidy_up(usbduxfastsub_t * usbduxfastsub_tmp)
{
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi_: usbduxfast: tiding up\n");
#endif
	if (!usbduxfastsub_tmp) {
		return;
	}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
	// shows the usb subsystem that the driver is down
	if (usbduxfastsub_tmp->interface) {
		usb_set_intfdata(usbduxfastsub_tmp->interface, NULL);
	}
#endif

	usbduxfastsub_tmp->probed = 0;

	if (usbduxfastsub_tmp->urbIn) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8)
		// waits until a running transfer is over
		// thus, under 2.4 hotplugging while a command
		// is running is not safe
		usb_kill_urb(usbduxfastsub_tmp->urbIn);
#endif
		if (usbduxfastsub_tmp->transfer_buffer) {
			kfree(usbduxfastsub_tmp->transfer_buffer);
			usbduxfastsub_tmp->transfer_buffer = NULL;
		}
		usb_free_urb(usbduxfastsub_tmp->urbIn);
		usbduxfastsub_tmp->urbIn = NULL;
	}
	if (usbduxfastsub_tmp->insnBuffer) {
		kfree(usbduxfastsub_tmp->insnBuffer);
		usbduxfastsub_tmp->insnBuffer = NULL;
	}
	if (usbduxfastsub_tmp->dux_commands) {
		kfree(usbduxfastsub_tmp->dux_commands);
		usbduxfastsub_tmp->dux_commands = NULL;
	}
	usbduxfastsub_tmp->ai_cmd_running = 0;
}

// allocate memory for the urbs and initialise them
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
static void *usbduxfastsub_probe(struct usb_device *udev,
	unsigned int interfnum, const struct usb_device_id *id)
{
#else
static int usbduxfastsub_probe(struct usb_interface *uinterf,
	const struct usb_device_id *id)
{
	struct usb_device *udev = interface_to_usbdev(uinterf);
#endif
	int i;
	int index;

	if (udev->speed != USB_SPEED_HIGH) {
		printk("comedi_: usbduxfast_: This driver needs USB 2.0 to operate. Aborting...\n");
		return -ENODEV;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi_: usbduxfast_: finding a free structure for the usb-device\n");
#endif
	down(&start_stop_sem);
	// look for a free place in the usbduxfast array
	index = -1;
	for (i = 0; i < NUMUSBDUXFAST; i++) {
		if (!(usbduxfastsub[i].probed)) {
			index = i;
			break;
		}
	}

	// no more space
	if (index == -1) {
		printk("Too many usbduxfast-devices connected.\n");
		up(&start_stop_sem);
		return -EMFILE;
	}
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi_: usbduxfast: usbduxfastsub[%d] is ready to connect to comedi.\n", index);
#endif

	init_MUTEX(&(usbduxfastsub[index].sem));
	// save a pointer to the usb device
	usbduxfastsub[index].usbdev = udev;

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
	// save the interface number
	usbduxfastsub[index].ifnum = interfnum;
#else
	// 2.6: save the interface itself
	usbduxfastsub[index].interface = uinterf;
	// get the interface number from the interface
	usbduxfastsub[index].ifnum = uinterf->altsetting->desc.bInterfaceNumber;
	// hand the private data over to the usb subsystem
	// will be needed for disconnect
	usb_set_intfdata(uinterf, &(usbduxfastsub[index]));
#endif

#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi_: usbduxfast: ifnum=%d\n", usbduxfastsub[index].ifnum);
#endif
	// create space for the commands going to the usb device
	usbduxfastsub[index].dux_commands = kmalloc(SIZEOFDUXBUFFER,
		GFP_KERNEL);
	if (!usbduxfastsub[index].dux_commands) {
		printk("comedi_: usbduxfast: error alloc space for dac commands\n");
		tidy_up(&(usbduxfastsub[index]));
		up(&start_stop_sem);
		return -ENOMEM;
	}
	// create space of the instruction buffer
	usbduxfastsub[index].insnBuffer = kmalloc(SIZEINSNBUF, GFP_KERNEL);
	if (!(usbduxfastsub[index].insnBuffer)) {
		printk("comedi_: usbduxfast: could not alloc space for insnBuffer\n");
		tidy_up(&(usbduxfastsub[index]));
		up(&start_stop_sem);
		return -ENOMEM;
	}
	// setting to alternate setting 1: enabling bulk ep
	i = usb_set_interface(usbduxfastsub[index].usbdev,
		usbduxfastsub[index].ifnum, 1);
	if (i < 0) {
		printk("comedi_: usbduxfast%d: could not switch to alternate setting 1.\n", index);
		tidy_up(&(usbduxfastsub[index]));
		up(&start_stop_sem);
		return -ENODEV;
	}
	usbduxfastsub[index].urbIn = usb_alloc_urb(0, GFP_KERNEL);
	if (usbduxfastsub[index].urbIn == NULL) {
		printk("comedi_: usbduxfast%d: Could not alloc. urb\n", index);
		tidy_up(&(usbduxfastsub[index]));
		up(&start_stop_sem);
		return -ENOMEM;
	}
	usbduxfastsub[index].transfer_buffer = kmalloc(SIZEINBUF, GFP_KERNEL);
	if (!(usbduxfastsub[index].transfer_buffer)) {
		printk("comedi_: usbduxfast%d: could not alloc. transb.\n",
			index);
		tidy_up(&(usbduxfastsub[index]));
		up(&start_stop_sem);
		return -ENOMEM;
	}
	// we've reached the bottom of the function
	usbduxfastsub[index].probed = 1;
	up(&start_stop_sem);
	printk("comedi_: usbduxfast%d has been successfully initialized.\n",
		index);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
	return (void *)(&usbduxfastsub[index]);
#else
	// success
	return 0;
#endif
}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
static void usbduxfastsub_disconnect(struct usb_device *udev, void *ptr)
{
	usbduxfastsub_t *usbduxfastsub_tmp = (usbduxfastsub_t *) ptr;
#else
static void usbduxfastsub_disconnect(struct usb_interface *intf)
{
	usbduxfastsub_t *usbduxfastsub_tmp = usb_get_intfdata(intf);
	struct usb_device *udev = interface_to_usbdev(intf);
#endif
	if (!usbduxfastsub_tmp) {
		printk("comedi_: usbduxfast: disconnect called with null pointer.\n");
		return;
	}
	if (usbduxfastsub_tmp->usbdev != udev) {
		printk("comedi_: usbduxfast: BUG! called with wrong ptr!!!\n");
		return;
	}
	down(&start_stop_sem);
	down(&usbduxfastsub_tmp->sem);
	tidy_up(usbduxfastsub_tmp);
	up(&usbduxfastsub_tmp->sem);
	up(&start_stop_sem);
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi_: usbduxfast: disconnected from the usb\n");
#endif
}

// is called when comedi-config is called
static int usbduxfast_attach(comedi_device * dev, comedi_devconfig * it)
{
	int ret;
	int index;
	int i;
	comedi_subdevice *s = NULL;
	dev->private = NULL;

	down(&start_stop_sem);
	// find a valid device which has been detected by the probe function of the usb
	index = -1;
	for (i = 0; i < NUMUSBDUXFAST; i++) {
		if ((usbduxfastsub[i].probed) && (!usbduxfastsub[i].attached)) {
			index = i;
			break;
		}
	}

	if (index < 0) {
		printk("comedi%d: usbduxfast: error: attach failed, no usbduxfast devs connected to the usb bus.\n", dev->minor);
		up(&start_stop_sem);
		return -ENODEV;
	}

	down(&(usbduxfastsub[index].sem));
	// pointer back to the corresponding comedi device
	usbduxfastsub[index].comedidev = dev;

	// trying to upload the firmware into the chip
	if (comedi_aux_data(it->options, 0) &&
		it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
		read_firmware(usbduxfastsub,
			comedi_aux_data(it->options, 0),
			it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]);
	}

	dev->board_name = BOARDNAME;

	/* set number of subdevices */
	dev->n_subdevices = N_SUBDEVICES;

	// allocate space for the subdevices
	if ((ret = alloc_subdevices(dev, N_SUBDEVICES)) < 0) {
		printk("comedi%d: usbduxfast: error alloc space for subdev\n",
			dev->minor);
		up(&start_stop_sem);
		return ret;
	}

	printk("comedi%d: usbduxfast: usb-device %d is attached to comedi.\n",
		dev->minor, index);
	// private structure is also simply the usb-structure
	dev->private = usbduxfastsub + index;
	// the first subdevice is the A/D converter
	s = dev->subdevices + SUBDEV_AD;
	// the URBs get the comedi subdevice
	// which is responsible for reading
	// this is the subdevice which reads data
	dev->read_subdev = s;
	// the subdevice receives as private structure the
	// usb-structure
	s->private = NULL;
	// analog input
	s->type = COMEDI_SUBD_AI;
	// readable and ref is to ground
	s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
	// 16 channels
	s->n_chan = 16;
	// length of the channellist
	s->len_chanlist = 16;
	// callback functions
	s->insn_read = usbduxfast_ai_insn_read;
	s->do_cmdtest = usbduxfast_ai_cmdtest;
	s->do_cmd = usbduxfast_ai_cmd;
	s->cancel = usbduxfast_ai_cancel;
	// max value from the A/D converter (12bit+1 bit for overflow)
	s->maxdata = 0x1000;
	// range table to convert to physical units
	s->range_table = &range_usbduxfast_ai_range;

	// finally decide that it's attached
	usbduxfastsub[index].attached = 1;

	up(&(usbduxfastsub[index].sem));

	up(&start_stop_sem);

	printk("comedi%d: successfully attached to usbduxfast.\n", dev->minor);

	return 0;
}

static int usbduxfast_detach(comedi_device * dev)
{
	usbduxfastsub_t *usbduxfastsub_tmp;

#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast: detach usb device\n", dev->minor);
#endif

	if (!dev) {
		printk("comedi?: usbduxfast: detach without dev variable...\n");
		return -EFAULT;
	}

	usbduxfastsub_tmp = dev->private;
	if (!usbduxfastsub_tmp) {
		printk("comedi?: usbduxfast: detach without ptr to usbduxfastsub[]\n");
		return -EFAULT;
	}

	down(&usbduxfastsub_tmp->sem);
	down(&start_stop_sem);
	// Don't allow detach to free the private structure
	// It's one entry of of usbduxfastsub[]
	dev->private = NULL;
	usbduxfastsub_tmp->attached = 0;
	usbduxfastsub_tmp->comedidev = NULL;
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi%d: usbduxfast: detach: successfully removed\n",
		dev->minor);
#endif
	up(&start_stop_sem);
	up(&usbduxfastsub_tmp->sem);
	return 0;
}

/* main driver struct */
static comedi_driver driver_usbduxfast = {
      driver_name:"usbduxfast",
      module:THIS_MODULE,
      attach:usbduxfast_attach,
      detach:usbduxfast_detach,
};

static void init_usb_devices(void)
{
	int index;
#ifdef CONFIG_COMEDI_DEBUG
	printk("comedi_: usbduxfast: setting all possible devs to invalid\n");
#endif
	// all devices entries are invalid to begin with
	// they will become valid by the probe function
	// and then finally by the attach-function
	for (index = 0; index < NUMUSBDUXFAST; index++) {
		memset(&(usbduxfastsub[index]), 0x00,
			sizeof(usbduxfastsub[index]));
		init_MUTEX(&(usbduxfastsub[index].sem));
	}
}

// Table with the USB-devices: just now only testing IDs
static struct usb_device_id usbduxfastsub_table[] = {
	//        { USB_DEVICE(0x4b4, 0x8613), //testing
	//        },
	{USB_DEVICE(0x13d8, 0x0010)	//real ID
		},
	{USB_DEVICE(0x13d8, 0x0011)	//real ID
		},
	{}			/* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, usbduxfastsub_table);

// The usbduxfastsub-driver
static struct usb_driver usbduxfastsub_driver = {
#ifdef COMEDI_HAVE_USB_DRIVER_OWNER
      owner:THIS_MODULE,
#endif
      name:BOARDNAME,
      probe:usbduxfastsub_probe,
      disconnect:usbduxfastsub_disconnect,
      id_table:usbduxfastsub_table,
};

// Can't use the nice macro as I have also to initialise the USB
// subsystem:
// registering the usb-system _and_ the comedi-driver
static int init_usbduxfast(void)
{
	printk(KERN_INFO KBUILD_MODNAME ": "
	       DRIVER_VERSION ":" DRIVER_DESC "\n");
	init_usb_devices();
	usb_register(&usbduxfastsub_driver);
	comedi_driver_register(&driver_usbduxfast);
	return 0;
}

// deregistering the comedi driver and the usb-subsystem
static void exit_usbduxfast(void)
{
	comedi_driver_unregister(&driver_usbduxfast);
	usb_deregister(&usbduxfastsub_driver);
}

module_init(init_usbduxfast);
module_exit(exit_usbduxfast);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");