Staging
v0.5.1
v0.5.1
https://github.com/torvalds/linux
Tip revision: 56299378726d5f2ba8d3c8cbbd13cb280ba45e4f authored by Linus Torvalds on 21 June 2011, 03:25:46 UTC
Linux 3.0-rc4
Linux 3.0-rc4
Tip revision: 5629937
vmk80xx.c
/*
comedi/drivers/vmk80xx.c
Velleman USB Board Low-Level Driver
Copyright (C) 2009 Manuel Gebele <forensixs@gmx.de>, Germany
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: vmk80xx
Description: Velleman USB Board Low-Level Driver
Devices: K8055/K8061 aka VM110/VM140
Author: Manuel Gebele <forensixs@gmx.de>
Updated: Sun, 10 May 2009 11:14:59 +0200
Status: works
Supports:
- analog input
- analog output
- digital input
- digital output
- counter
- pwm
*/
/*
Changelog:
0.8.81 -3- code completely rewritten (adjust driver logic)
0.8.81 -2- full support for K8061
0.8.81 -1- fix some mistaken among others the number of
supported boards and I/O handling
0.7.76 -4- renamed to vmk80xx
0.7.76 -3- detect K8061 (only theoretically supported)
0.7.76 -2- code completely rewritten (adjust driver logic)
0.7.76 -1- support for digital and counter subdevice
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/errno.h>
#include <linux/input.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/usb.h>
#include <linux/uaccess.h>
#include "../comedidev.h"
#define BOARDNAME "vmk80xx"
MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
MODULE_VERSION("0.8.01");
MODULE_LICENSE("GPL");
enum {
DEVICE_VMK8055,
DEVICE_VMK8061
};
static const struct usb_device_id vmk80xx_id_table[] = {
{USB_DEVICE(0x10cf, 0x5500), .driver_info = DEVICE_VMK8055},
{USB_DEVICE(0x10cf, 0x5501), .driver_info = DEVICE_VMK8055},
{USB_DEVICE(0x10cf, 0x5502), .driver_info = DEVICE_VMK8055},
{USB_DEVICE(0x10cf, 0x5503), .driver_info = DEVICE_VMK8055},
{USB_DEVICE(0x10cf, 0x8061), .driver_info = DEVICE_VMK8061},
{USB_DEVICE(0x10cf, 0x8062), .driver_info = DEVICE_VMK8061},
{USB_DEVICE(0x10cf, 0x8063), .driver_info = DEVICE_VMK8061},
{USB_DEVICE(0x10cf, 0x8064), .driver_info = DEVICE_VMK8061},
{USB_DEVICE(0x10cf, 0x8065), .driver_info = DEVICE_VMK8061},
{USB_DEVICE(0x10cf, 0x8066), .driver_info = DEVICE_VMK8061},
{USB_DEVICE(0x10cf, 0x8067), .driver_info = DEVICE_VMK8061},
{USB_DEVICE(0x10cf, 0x8068), .driver_info = DEVICE_VMK8061},
{} /* terminating entry */
};
MODULE_DEVICE_TABLE(usb, vmk80xx_id_table);
#define VMK8055_DI_REG 0x00
#define VMK8055_DO_REG 0x01
#define VMK8055_AO1_REG 0x02
#define VMK8055_AO2_REG 0x03
#define VMK8055_AI1_REG 0x02
#define VMK8055_AI2_REG 0x03
#define VMK8055_CNT1_REG 0x04
#define VMK8055_CNT2_REG 0x06
#define VMK8061_CH_REG 0x01
#define VMK8061_DI_REG 0x01
#define VMK8061_DO_REG 0x01
#define VMK8061_PWM_REG1 0x01
#define VMK8061_PWM_REG2 0x02
#define VMK8061_CNT_REG 0x02
#define VMK8061_AO_REG 0x02
#define VMK8061_AI_REG1 0x02
#define VMK8061_AI_REG2 0x03
#define VMK8055_CMD_RST 0x00
#define VMK8055_CMD_DEB1_TIME 0x01
#define VMK8055_CMD_DEB2_TIME 0x02
#define VMK8055_CMD_RST_CNT1 0x03
#define VMK8055_CMD_RST_CNT2 0x04
#define VMK8055_CMD_WRT_AD 0x05
#define VMK8061_CMD_RD_AI 0x00
#define VMK8061_CMR_RD_ALL_AI 0x01 /* !non-active! */
#define VMK8061_CMD_SET_AO 0x02
#define VMK8061_CMD_SET_ALL_AO 0x03 /* !non-active! */
#define VMK8061_CMD_OUT_PWM 0x04
#define VMK8061_CMD_RD_DI 0x05
#define VMK8061_CMD_DO 0x06 /* !non-active! */
#define VMK8061_CMD_CLR_DO 0x07
#define VMK8061_CMD_SET_DO 0x08
#define VMK8061_CMD_RD_CNT 0x09 /* TODO: completely pointless? */
#define VMK8061_CMD_RST_CNT 0x0a /* TODO: completely pointless? */
#define VMK8061_CMD_RD_VERSION 0x0b /* internal usage */
#define VMK8061_CMD_RD_JMP_STAT 0x0c /* TODO: not implemented yet */
#define VMK8061_CMD_RD_PWR_STAT 0x0d /* internal usage */
#define VMK8061_CMD_RD_DO 0x0e
#define VMK8061_CMD_RD_AO 0x0f
#define VMK8061_CMD_RD_PWM 0x10
#define VMK80XX_MAX_BOARDS COMEDI_NUM_BOARD_MINORS
#define TRANS_OUT_BUSY 1
#define TRANS_IN_BUSY 2
#define TRANS_IN_RUNNING 3
#define IC3_VERSION (1 << 0)
#define IC6_VERSION (1 << 1)
#define URB_RCV_FLAG (1 << 0)
#define URB_SND_FLAG (1 << 1)
#define CONFIG_VMK80XX_DEBUG
#undef CONFIG_VMK80XX_DEBUG
#ifdef CONFIG_VMK80XX_DEBUG
static int dbgvm = 1;
#else
static int dbgvm;
#endif
#ifdef CONFIG_COMEDI_DEBUG
static int dbgcm = 1;
#else
static int dbgcm;
#endif
#define dbgvm(fmt, arg...) \
do { \
if (dbgvm) \
printk(KERN_DEBUG fmt, ##arg); \
} while (0)
#define dbgcm(fmt, arg...) \
do { \
if (dbgcm) \
printk(KERN_DEBUG fmt, ##arg); \
} while (0)
enum vmk80xx_model {
VMK8055_MODEL,
VMK8061_MODEL
};
struct firmware_version {
unsigned char ic3_vers[32]; /* USB-Controller */
unsigned char ic6_vers[32]; /* CPU */
};
static const struct comedi_lrange vmk8055_range = {
1, {UNI_RANGE(5)}
};
static const struct comedi_lrange vmk8061_range = {
2, {UNI_RANGE(5), UNI_RANGE(10)}
};
struct vmk80xx_board {
const char *name;
enum vmk80xx_model model;
const struct comedi_lrange *range;
__u8 ai_chans;
__le16 ai_bits;
__u8 ao_chans;
__le16 ao_bits;
__u8 di_chans;
__le16 di_bits;
__u8 do_chans;
__le16 do_bits;
__u8 cnt_chans;
__le16 cnt_bits;
__u8 pwm_chans;
__le16 pwm_bits;
};
enum {
VMK80XX_SUBD_AI,
VMK80XX_SUBD_AO,
VMK80XX_SUBD_DI,
VMK80XX_SUBD_DO,
VMK80XX_SUBD_CNT,
VMK80XX_SUBD_PWM,
};
struct vmk80xx_usb {
struct usb_device *udev;
struct usb_interface *intf;
struct usb_endpoint_descriptor *ep_rx;
struct usb_endpoint_descriptor *ep_tx;
struct usb_anchor rx_anchor;
struct usb_anchor tx_anchor;
struct vmk80xx_board board;
struct firmware_version fw;
struct semaphore limit_sem;
wait_queue_head_t read_wait;
wait_queue_head_t write_wait;
unsigned char *usb_rx_buf;
unsigned char *usb_tx_buf;
unsigned long flags;
int probed;
int attached;
int count;
};
static struct vmk80xx_usb vmb[VMK80XX_MAX_BOARDS];
static DEFINE_MUTEX(glb_mutex);
static void vmk80xx_tx_callback(struct urb *urb)
{
struct vmk80xx_usb *dev = urb->context;
int stat = urb->status;
dbgvm("vmk80xx: %s\n", __func__);
if (stat && !(stat == -ENOENT
|| stat == -ECONNRESET || stat == -ESHUTDOWN))
dbgcm("comedi#: vmk80xx: %s - nonzero urb status (%d)\n",
__func__, stat);
if (!test_bit(TRANS_OUT_BUSY, &dev->flags))
return;
clear_bit(TRANS_OUT_BUSY, &dev->flags);
wake_up_interruptible(&dev->write_wait);
}
static void vmk80xx_rx_callback(struct urb *urb)
{
struct vmk80xx_usb *dev = urb->context;
int stat = urb->status;
dbgvm("vmk80xx: %s\n", __func__);
switch (stat) {
case 0:
break;
case -ENOENT:
case -ECONNRESET:
case -ESHUTDOWN:
break;
default:
dbgcm("comedi#: vmk80xx: %s - nonzero urb status (%d)\n",
__func__, stat);
goto resubmit;
}
goto exit;
resubmit:
if (test_bit(TRANS_IN_RUNNING, &dev->flags) && dev->intf) {
usb_anchor_urb(urb, &dev->rx_anchor);
if (!usb_submit_urb(urb, GFP_KERNEL))
goto exit;
err("comedi#: vmk80xx: %s - submit urb failed\n", __func__);
usb_unanchor_urb(urb);
}
exit:
clear_bit(TRANS_IN_BUSY, &dev->flags);
wake_up_interruptible(&dev->read_wait);
}
static int vmk80xx_check_data_link(struct vmk80xx_usb *dev)
{
unsigned int tx_pipe;
unsigned int rx_pipe;
unsigned char tx[1];
unsigned char rx[2];
dbgvm("vmk80xx: %s\n", __func__);
tx_pipe = usb_sndbulkpipe(dev->udev, 0x01);
rx_pipe = usb_rcvbulkpipe(dev->udev, 0x81);
tx[0] = VMK8061_CMD_RD_PWR_STAT;
/*
* Check that IC6 (PIC16F871) is powered and
* running and the data link between IC3 and
* IC6 is working properly
*/
usb_bulk_msg(dev->udev, tx_pipe, tx, 1, NULL, dev->ep_tx->bInterval);
usb_bulk_msg(dev->udev, rx_pipe, rx, 2, NULL, HZ * 10);
return (int)rx[1];
}
static void vmk80xx_read_eeprom(struct vmk80xx_usb *dev, int flag)
{
unsigned int tx_pipe;
unsigned int rx_pipe;
unsigned char tx[1];
unsigned char rx[64];
int cnt;
dbgvm("vmk80xx: %s\n", __func__);
tx_pipe = usb_sndbulkpipe(dev->udev, 0x01);
rx_pipe = usb_rcvbulkpipe(dev->udev, 0x81);
tx[0] = VMK8061_CMD_RD_VERSION;
/*
* Read the firmware version info of IC3 and
* IC6 from the internal EEPROM of the IC
*/
usb_bulk_msg(dev->udev, tx_pipe, tx, 1, NULL, dev->ep_tx->bInterval);
usb_bulk_msg(dev->udev, rx_pipe, rx, 64, &cnt, HZ * 10);
rx[cnt] = '\0';
if (flag & IC3_VERSION)
strncpy(dev->fw.ic3_vers, rx + 1, 24);
else /* IC6_VERSION */
strncpy(dev->fw.ic6_vers, rx + 25, 24);
}
static int vmk80xx_reset_device(struct vmk80xx_usb *dev)
{
struct urb *urb;
unsigned int tx_pipe;
int ival;
size_t size;
dbgvm("vmk80xx: %s\n", __func__);
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb)
return -ENOMEM;
tx_pipe = usb_sndintpipe(dev->udev, 0x01);
ival = dev->ep_tx->bInterval;
size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
dev->usb_tx_buf[0] = VMK8055_CMD_RST;
dev->usb_tx_buf[1] = 0x00;
dev->usb_tx_buf[2] = 0x00;
dev->usb_tx_buf[3] = 0x00;
dev->usb_tx_buf[4] = 0x00;
dev->usb_tx_buf[5] = 0x00;
dev->usb_tx_buf[6] = 0x00;
dev->usb_tx_buf[7] = 0x00;
usb_fill_int_urb(urb, dev->udev, tx_pipe, dev->usb_tx_buf,
size, vmk80xx_tx_callback, dev, ival);
usb_anchor_urb(urb, &dev->tx_anchor);
return usb_submit_urb(urb, GFP_KERNEL);
}
static void vmk80xx_build_int_urb(struct urb *urb, int flag)
{
struct vmk80xx_usb *dev = urb->context;
__u8 rx_addr;
__u8 tx_addr;
unsigned int pipe;
unsigned char *buf;
size_t size;
void (*callback) (struct urb *);
int ival;
dbgvm("vmk80xx: %s\n", __func__);
if (flag & URB_RCV_FLAG) {
rx_addr = dev->ep_rx->bEndpointAddress;
pipe = usb_rcvintpipe(dev->udev, rx_addr);
buf = dev->usb_rx_buf;
size = le16_to_cpu(dev->ep_rx->wMaxPacketSize);
callback = vmk80xx_rx_callback;
ival = dev->ep_rx->bInterval;
} else { /* URB_SND_FLAG */
tx_addr = dev->ep_tx->bEndpointAddress;
pipe = usb_sndintpipe(dev->udev, tx_addr);
buf = dev->usb_tx_buf;
size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
callback = vmk80xx_tx_callback;
ival = dev->ep_tx->bInterval;
}
usb_fill_int_urb(urb, dev->udev, pipe, buf, size, callback, dev, ival);
}
static void vmk80xx_do_bulk_msg(struct vmk80xx_usb *dev)
{
__u8 tx_addr;
__u8 rx_addr;
unsigned int tx_pipe;
unsigned int rx_pipe;
size_t size;
dbgvm("vmk80xx: %s\n", __func__);
set_bit(TRANS_IN_BUSY, &dev->flags);
set_bit(TRANS_OUT_BUSY, &dev->flags);
tx_addr = dev->ep_tx->bEndpointAddress;
rx_addr = dev->ep_rx->bEndpointAddress;
tx_pipe = usb_sndbulkpipe(dev->udev, tx_addr);
rx_pipe = usb_rcvbulkpipe(dev->udev, rx_addr);
/*
* The max packet size attributes of the K8061
* input/output endpoints are identical
*/
size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
usb_bulk_msg(dev->udev, tx_pipe, dev->usb_tx_buf,
size, NULL, dev->ep_tx->bInterval);
usb_bulk_msg(dev->udev, rx_pipe, dev->usb_rx_buf, size, NULL, HZ * 10);
clear_bit(TRANS_OUT_BUSY, &dev->flags);
clear_bit(TRANS_IN_BUSY, &dev->flags);
}
static int vmk80xx_read_packet(struct vmk80xx_usb *dev)
{
struct urb *urb;
int retval;
dbgvm("vmk80xx: %s\n", __func__);
if (!dev->intf)
return -ENODEV;
/* Only useful for interrupt transfers */
if (test_bit(TRANS_IN_BUSY, &dev->flags))
if (wait_event_interruptible(dev->read_wait,
!test_bit(TRANS_IN_BUSY,
&dev->flags)))
return -ERESTART;
if (dev->board.model == VMK8061_MODEL) {
vmk80xx_do_bulk_msg(dev);
return 0;
}
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb)
return -ENOMEM;
urb->context = dev;
vmk80xx_build_int_urb(urb, URB_RCV_FLAG);
set_bit(TRANS_IN_RUNNING, &dev->flags);
set_bit(TRANS_IN_BUSY, &dev->flags);
usb_anchor_urb(urb, &dev->rx_anchor);
retval = usb_submit_urb(urb, GFP_KERNEL);
if (!retval)
goto exit;
clear_bit(TRANS_IN_RUNNING, &dev->flags);
usb_unanchor_urb(urb);
exit:
usb_free_urb(urb);
return retval;
}
static int vmk80xx_write_packet(struct vmk80xx_usb *dev, int cmd)
{
struct urb *urb;
int retval;
dbgvm("vmk80xx: %s\n", __func__);
if (!dev->intf)
return -ENODEV;
if (test_bit(TRANS_OUT_BUSY, &dev->flags))
if (wait_event_interruptible(dev->write_wait,
!test_bit(TRANS_OUT_BUSY,
&dev->flags)))
return -ERESTART;
if (dev->board.model == VMK8061_MODEL) {
dev->usb_tx_buf[0] = cmd;
vmk80xx_do_bulk_msg(dev);
return 0;
}
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb)
return -ENOMEM;
urb->context = dev;
vmk80xx_build_int_urb(urb, URB_SND_FLAG);
set_bit(TRANS_OUT_BUSY, &dev->flags);
usb_anchor_urb(urb, &dev->tx_anchor);
dev->usb_tx_buf[0] = cmd;
retval = usb_submit_urb(urb, GFP_KERNEL);
if (!retval)
goto exit;
clear_bit(TRANS_OUT_BUSY, &dev->flags);
usb_unanchor_urb(urb);
exit:
usb_free_urb(urb);
return retval;
}
#define DIR_IN 1
#define DIR_OUT 2
static int rudimentary_check(struct vmk80xx_usb *dev, int dir)
{
if (!dev)
return -EFAULT;
if (!dev->probed)
return -ENODEV;
if (!dev->attached)
return -ENODEV;
if (dir & DIR_IN) {
if (test_bit(TRANS_IN_BUSY, &dev->flags))
return -EBUSY;
}
if (dir & DIR_OUT) {
if (test_bit(TRANS_OUT_BUSY, &dev->flags))
return -EBUSY;
}
return 0;
}
static int vmk80xx_ai_rinsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int chan;
int reg[2];
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_IN);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
switch (dev->board.model) {
case VMK8055_MODEL:
if (!chan)
reg[0] = VMK8055_AI1_REG;
else
reg[0] = VMK8055_AI2_REG;
break;
case VMK8061_MODEL:
reg[0] = VMK8061_AI_REG1;
reg[1] = VMK8061_AI_REG2;
dev->usb_tx_buf[0] = VMK8061_CMD_RD_AI;
dev->usb_tx_buf[VMK8061_CH_REG] = chan;
break;
}
for (n = 0; n < insn->n; n++) {
if (vmk80xx_read_packet(dev))
break;
if (dev->board.model == VMK8055_MODEL) {
data[n] = dev->usb_rx_buf[reg[0]];
continue;
}
/* VMK8061_MODEL */
data[n] = dev->usb_rx_buf[reg[0]] + 256 *
dev->usb_rx_buf[reg[1]];
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_ao_winsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int chan;
int cmd;
int reg;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_OUT);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
switch (dev->board.model) {
case VMK8055_MODEL:
cmd = VMK8055_CMD_WRT_AD;
if (!chan)
reg = VMK8055_AO1_REG;
else
reg = VMK8055_AO2_REG;
break;
default: /* NOTE: avoid compiler warnings */
cmd = VMK8061_CMD_SET_AO;
reg = VMK8061_AO_REG;
dev->usb_tx_buf[VMK8061_CH_REG] = chan;
break;
}
for (n = 0; n < insn->n; n++) {
dev->usb_tx_buf[reg] = data[n];
if (vmk80xx_write_packet(dev, cmd))
break;
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_ao_rinsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int chan;
int reg;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_IN);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
reg = VMK8061_AO_REG - 1;
dev->usb_tx_buf[0] = VMK8061_CMD_RD_AO;
for (n = 0; n < insn->n; n++) {
if (vmk80xx_read_packet(dev))
break;
data[n] = dev->usb_rx_buf[reg + chan];
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_di_bits(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
unsigned char *rx_buf;
int reg;
int retval;
dbgvm("vmk80xx: %s\n", __func__);
retval = rudimentary_check(dev, DIR_IN);
if (retval)
return retval;
down(&dev->limit_sem);
rx_buf = dev->usb_rx_buf;
if (dev->board.model == VMK8061_MODEL) {
reg = VMK8061_DI_REG;
dev->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
} else {
reg = VMK8055_DI_REG;
}
retval = vmk80xx_read_packet(dev);
if (!retval) {
if (dev->board.model == VMK8055_MODEL)
data[1] = (((rx_buf[reg] >> 4) & 0x03) |
((rx_buf[reg] << 2) & 0x04) |
((rx_buf[reg] >> 3) & 0x18));
else
data[1] = rx_buf[reg];
retval = 2;
}
up(&dev->limit_sem);
return retval;
}
static int vmk80xx_di_rinsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int chan;
unsigned char *rx_buf;
int reg;
int inp;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_IN);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
rx_buf = dev->usb_rx_buf;
if (dev->board.model == VMK8061_MODEL) {
reg = VMK8061_DI_REG;
dev->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
} else {
reg = VMK8055_DI_REG;
}
for (n = 0; n < insn->n; n++) {
if (vmk80xx_read_packet(dev))
break;
if (dev->board.model == VMK8055_MODEL)
inp = (((rx_buf[reg] >> 4) & 0x03) |
((rx_buf[reg] << 2) & 0x04) |
((rx_buf[reg] >> 3) & 0x18));
else
inp = rx_buf[reg];
data[n] = (inp >> chan) & 1;
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_do_winsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int chan;
unsigned char *tx_buf;
int reg;
int cmd;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_OUT);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
tx_buf = dev->usb_tx_buf;
for (n = 0; n < insn->n; n++) {
if (dev->board.model == VMK8055_MODEL) {
reg = VMK8055_DO_REG;
cmd = VMK8055_CMD_WRT_AD;
if (data[n] == 1)
tx_buf[reg] |= (1 << chan);
else
tx_buf[reg] ^= (1 << chan);
} else { /* VMK8061_MODEL */
reg = VMK8061_DO_REG;
if (data[n] == 1) {
cmd = VMK8061_CMD_SET_DO;
tx_buf[reg] = 1 << chan;
} else {
cmd = VMK8061_CMD_CLR_DO;
tx_buf[reg] = 0xff - (1 << chan);
}
}
if (vmk80xx_write_packet(dev, cmd))
break;
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_do_rinsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int chan;
int reg;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_IN);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
reg = VMK8061_DO_REG;
dev->usb_tx_buf[0] = VMK8061_CMD_RD_DO;
for (n = 0; n < insn->n; n++) {
if (vmk80xx_read_packet(dev))
break;
data[n] = (dev->usb_rx_buf[reg] >> chan) & 1;
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_do_bits(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
unsigned char *rx_buf, *tx_buf;
int dir, reg, cmd;
int retval;
dbgvm("vmk80xx: %s\n", __func__);
dir = 0;
if (data[0])
dir |= DIR_OUT;
if (dev->board.model == VMK8061_MODEL)
dir |= DIR_IN;
retval = rudimentary_check(dev, dir);
if (retval)
return retval;
down(&dev->limit_sem);
rx_buf = dev->usb_rx_buf;
tx_buf = dev->usb_tx_buf;
if (data[0]) {
if (dev->board.model == VMK8055_MODEL) {
reg = VMK8055_DO_REG;
cmd = VMK8055_CMD_WRT_AD;
} else { /* VMK8061_MODEL */
reg = VMK8061_DO_REG;
cmd = VMK8061_CMD_DO;
}
tx_buf[reg] &= ~data[0];
tx_buf[reg] |= (data[0] & data[1]);
retval = vmk80xx_write_packet(dev, cmd);
if (retval)
goto out;
}
if (dev->board.model == VMK8061_MODEL) {
reg = VMK8061_DO_REG;
tx_buf[0] = VMK8061_CMD_RD_DO;
retval = vmk80xx_read_packet(dev);
if (!retval) {
data[1] = rx_buf[reg];
retval = 2;
}
} else {
data[1] = tx_buf[reg];
retval = 2;
}
out:
up(&dev->limit_sem);
return retval;
}
static int vmk80xx_cnt_rinsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int chan;
int reg[2];
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_IN);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
switch (dev->board.model) {
case VMK8055_MODEL:
if (!chan)
reg[0] = VMK8055_CNT1_REG;
else
reg[0] = VMK8055_CNT2_REG;
break;
case VMK8061_MODEL:
reg[0] = VMK8061_CNT_REG;
reg[1] = VMK8061_CNT_REG;
dev->usb_tx_buf[0] = VMK8061_CMD_RD_CNT;
break;
}
for (n = 0; n < insn->n; n++) {
if (vmk80xx_read_packet(dev))
break;
if (dev->board.model == VMK8055_MODEL)
data[n] = dev->usb_rx_buf[reg[0]];
else /* VMK8061_MODEL */
data[n] = dev->usb_rx_buf[reg[0] * (chan + 1) + 1]
+ 256 * dev->usb_rx_buf[reg[1] * 2 + 2];
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_cnt_cinsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
unsigned int insn_cmd;
int chan;
int cmd;
int reg;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_OUT);
if (n)
return n;
down(&dev->limit_sem);
insn_cmd = data[0];
if (insn_cmd != INSN_CONFIG_RESET && insn_cmd != GPCT_RESET)
return -EINVAL;
chan = CR_CHAN(insn->chanspec);
if (dev->board.model == VMK8055_MODEL) {
if (!chan) {
cmd = VMK8055_CMD_RST_CNT1;
reg = VMK8055_CNT1_REG;
} else {
cmd = VMK8055_CMD_RST_CNT2;
reg = VMK8055_CNT2_REG;
}
dev->usb_tx_buf[reg] = 0x00;
} else {
cmd = VMK8061_CMD_RST_CNT;
}
for (n = 0; n < insn->n; n++)
if (vmk80xx_write_packet(dev, cmd))
break;
up(&dev->limit_sem);
return n;
}
static int vmk80xx_cnt_winsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
unsigned long debtime;
unsigned long val;
int chan;
int cmd;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_OUT);
if (n)
return n;
down(&dev->limit_sem);
chan = CR_CHAN(insn->chanspec);
if (!chan)
cmd = VMK8055_CMD_DEB1_TIME;
else
cmd = VMK8055_CMD_DEB2_TIME;
for (n = 0; n < insn->n; n++) {
debtime = data[n];
if (debtime == 0)
debtime = 1;
/* TODO: Prevent overflows */
if (debtime > 7450)
debtime = 7450;
val = int_sqrt(debtime * 1000 / 115);
if (((val + 1) * val) < debtime * 1000 / 115)
val += 1;
dev->usb_tx_buf[6 + chan] = val;
if (vmk80xx_write_packet(dev, cmd))
break;
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_pwm_rinsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
int reg[2];
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_IN);
if (n)
return n;
down(&dev->limit_sem);
reg[0] = VMK8061_PWM_REG1;
reg[1] = VMK8061_PWM_REG2;
dev->usb_tx_buf[0] = VMK8061_CMD_RD_PWM;
for (n = 0; n < insn->n; n++) {
if (vmk80xx_read_packet(dev))
break;
data[n] = dev->usb_rx_buf[reg[0]] + 4 * dev->usb_rx_buf[reg[1]];
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_pwm_winsn(struct comedi_device *cdev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct vmk80xx_usb *dev = cdev->private;
unsigned char *tx_buf;
int reg[2];
int cmd;
int n;
dbgvm("vmk80xx: %s\n", __func__);
n = rudimentary_check(dev, DIR_OUT);
if (n)
return n;
down(&dev->limit_sem);
tx_buf = dev->usb_tx_buf;
reg[0] = VMK8061_PWM_REG1;
reg[1] = VMK8061_PWM_REG2;
cmd = VMK8061_CMD_OUT_PWM;
/*
* The followin piece of code was translated from the inline
* assembler code in the DLL source code.
*
* asm
* mov eax, k ; k is the value (data[n])
* and al, 03h ; al are the lower 8 bits of eax
* mov lo, al ; lo is the low part (tx_buf[reg[0]])
* mov eax, k
* shr eax, 2 ; right shift eax register by 2
* mov hi, al ; hi is the high part (tx_buf[reg[1]])
* end;
*/
for (n = 0; n < insn->n; n++) {
tx_buf[reg[0]] = (unsigned char)(data[n] & 0x03);
tx_buf[reg[1]] = (unsigned char)(data[n] >> 2) & 0xff;
if (vmk80xx_write_packet(dev, cmd))
break;
}
up(&dev->limit_sem);
return n;
}
static int vmk80xx_attach(struct comedi_device *cdev,
struct comedi_devconfig *it)
{
int i;
struct vmk80xx_usb *dev;
int n_subd;
struct comedi_subdevice *s;
int minor;
dbgvm("vmk80xx: %s\n", __func__);
mutex_lock(&glb_mutex);
for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
if (vmb[i].probed && !vmb[i].attached)
break;
if (i == VMK80XX_MAX_BOARDS) {
mutex_unlock(&glb_mutex);
return -ENODEV;
}
dev = &vmb[i];
down(&dev->limit_sem);
cdev->board_name = dev->board.name;
cdev->private = dev;
if (dev->board.model == VMK8055_MODEL)
n_subd = 5;
else
n_subd = 6;
if (alloc_subdevices(cdev, n_subd) < 0) {
up(&dev->limit_sem);
mutex_unlock(&glb_mutex);
return -ENOMEM;
}
/* Analog input subdevice */
s = cdev->subdevices + VMK80XX_SUBD_AI;
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
s->n_chan = dev->board.ai_chans;
s->maxdata = (1 << dev->board.ai_bits) - 1;
s->range_table = dev->board.range;
s->insn_read = vmk80xx_ai_rinsn;
/* Analog output subdevice */
s = cdev->subdevices + VMK80XX_SUBD_AO;
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITEABLE | SDF_GROUND;
s->n_chan = dev->board.ao_chans;
s->maxdata = (1 << dev->board.ao_bits) - 1;
s->range_table = dev->board.range;
s->insn_write = vmk80xx_ao_winsn;
if (dev->board.model == VMK8061_MODEL) {
s->subdev_flags |= SDF_READABLE;
s->insn_read = vmk80xx_ao_rinsn;
}
/* Digital input subdevice */
s = cdev->subdevices + VMK80XX_SUBD_DI;
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
s->n_chan = dev->board.di_chans;
s->maxdata = 1;
s->insn_read = vmk80xx_di_rinsn;
s->insn_bits = vmk80xx_di_bits;
/* Digital output subdevice */
s = cdev->subdevices + VMK80XX_SUBD_DO;
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITEABLE | SDF_GROUND;
s->n_chan = dev->board.do_chans;
s->maxdata = 1;
s->insn_write = vmk80xx_do_winsn;
s->insn_bits = vmk80xx_do_bits;
if (dev->board.model == VMK8061_MODEL) {
s->subdev_flags |= SDF_READABLE;
s->insn_read = vmk80xx_do_rinsn;
}
/* Counter subdevice */
s = cdev->subdevices + VMK80XX_SUBD_CNT;
s->type = COMEDI_SUBD_COUNTER;
s->subdev_flags = SDF_READABLE;
s->n_chan = dev->board.cnt_chans;
s->insn_read = vmk80xx_cnt_rinsn;
s->insn_config = vmk80xx_cnt_cinsn;
if (dev->board.model == VMK8055_MODEL) {
s->subdev_flags |= SDF_WRITEABLE;
s->maxdata = (1 << dev->board.cnt_bits) - 1;
s->insn_write = vmk80xx_cnt_winsn;
}
/* PWM subdevice */
if (dev->board.model == VMK8061_MODEL) {
s = cdev->subdevices + VMK80XX_SUBD_PWM;
s->type = COMEDI_SUBD_PWM;
s->subdev_flags = SDF_READABLE | SDF_WRITEABLE;
s->n_chan = dev->board.pwm_chans;
s->maxdata = (1 << dev->board.pwm_bits) - 1;
s->insn_read = vmk80xx_pwm_rinsn;
s->insn_write = vmk80xx_pwm_winsn;
}
dev->attached = 1;
minor = cdev->minor;
printk(KERN_INFO
"comedi%d: vmk80xx: board #%d [%s] attached to comedi\n",
minor, dev->count, dev->board.name);
up(&dev->limit_sem);
mutex_unlock(&glb_mutex);
return 0;
}
static int vmk80xx_detach(struct comedi_device *cdev)
{
struct vmk80xx_usb *dev;
int minor;
dbgvm("vmk80xx: %s\n", __func__);
if (!cdev)
return -EFAULT;
dev = cdev->private;
if (!dev)
return -EFAULT;
down(&dev->limit_sem);
cdev->private = NULL;
dev->attached = 0;
minor = cdev->minor;
printk(KERN_INFO
"comedi%d: vmk80xx: board #%d [%s] detached from comedi\n",
minor, dev->count, dev->board.name);
up(&dev->limit_sem);
return 0;
}
static int vmk80xx_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
int i;
struct vmk80xx_usb *dev;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *ep_desc;
size_t size;
dbgvm("vmk80xx: %s\n", __func__);
mutex_lock(&glb_mutex);
for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
if (!vmb[i].probed)
break;
if (i == VMK80XX_MAX_BOARDS) {
mutex_unlock(&glb_mutex);
return -EMFILE;
}
dev = &vmb[i];
memset(dev, 0x00, sizeof(struct vmk80xx_usb));
dev->count = i;
iface_desc = intf->cur_altsetting;
if (iface_desc->desc.bNumEndpoints != 2)
goto error;
for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
ep_desc = &iface_desc->endpoint[i].desc;
if (usb_endpoint_is_int_in(ep_desc)) {
dev->ep_rx = ep_desc;
continue;
}
if (usb_endpoint_is_int_out(ep_desc)) {
dev->ep_tx = ep_desc;
continue;
}
if (usb_endpoint_is_bulk_in(ep_desc)) {
dev->ep_rx = ep_desc;
continue;
}
if (usb_endpoint_is_bulk_out(ep_desc)) {
dev->ep_tx = ep_desc;
continue;
}
}
if (!dev->ep_rx || !dev->ep_tx)
goto error;
size = le16_to_cpu(dev->ep_rx->wMaxPacketSize);
dev->usb_rx_buf = kmalloc(size, GFP_KERNEL);
if (!dev->usb_rx_buf) {
mutex_unlock(&glb_mutex);
return -ENOMEM;
}
size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
dev->usb_tx_buf = kmalloc(size, GFP_KERNEL);
if (!dev->usb_tx_buf) {
kfree(dev->usb_rx_buf);
mutex_unlock(&glb_mutex);
return -ENOMEM;
}
dev->udev = interface_to_usbdev(intf);
dev->intf = intf;
sema_init(&dev->limit_sem, 8);
init_waitqueue_head(&dev->read_wait);
init_waitqueue_head(&dev->write_wait);
init_usb_anchor(&dev->rx_anchor);
init_usb_anchor(&dev->tx_anchor);
usb_set_intfdata(intf, dev);
switch (id->driver_info) {
case DEVICE_VMK8055:
dev->board.name = "K8055 (VM110)";
dev->board.model = VMK8055_MODEL;
dev->board.range = &vmk8055_range;
dev->board.ai_chans = 2;
dev->board.ai_bits = 8;
dev->board.ao_chans = 2;
dev->board.ao_bits = 8;
dev->board.di_chans = 5;
dev->board.di_bits = 1;
dev->board.do_chans = 8;
dev->board.do_bits = 1;
dev->board.cnt_chans = 2;
dev->board.cnt_bits = 16;
dev->board.pwm_chans = 0;
dev->board.pwm_bits = 0;
break;
case DEVICE_VMK8061:
dev->board.name = "K8061 (VM140)";
dev->board.model = VMK8061_MODEL;
dev->board.range = &vmk8061_range;
dev->board.ai_chans = 8;
dev->board.ai_bits = 10;
dev->board.ao_chans = 8;
dev->board.ao_bits = 8;
dev->board.di_chans = 8;
dev->board.di_bits = 1;
dev->board.do_chans = 8;
dev->board.do_bits = 1;
dev->board.cnt_chans = 2;
dev->board.cnt_bits = 0;
dev->board.pwm_chans = 1;
dev->board.pwm_bits = 10;
break;
}
if (dev->board.model == VMK8061_MODEL) {
vmk80xx_read_eeprom(dev, IC3_VERSION);
printk(KERN_INFO "comedi#: vmk80xx: %s\n", dev->fw.ic3_vers);
if (vmk80xx_check_data_link(dev)) {
vmk80xx_read_eeprom(dev, IC6_VERSION);
printk(KERN_INFO "comedi#: vmk80xx: %s\n",
dev->fw.ic6_vers);
} else {
dbgcm("comedi#: vmk80xx: no conn. to CPU\n");
}
}
if (dev->board.model == VMK8055_MODEL)
vmk80xx_reset_device(dev);
dev->probed = 1;
printk(KERN_INFO "comedi#: vmk80xx: board #%d [%s] now attached\n",
dev->count, dev->board.name);
mutex_unlock(&glb_mutex);
comedi_usb_auto_config(dev->udev, BOARDNAME);
return 0;
error:
mutex_unlock(&glb_mutex);
return -ENODEV;
}
static void vmk80xx_disconnect(struct usb_interface *intf)
{
struct vmk80xx_usb *dev = usb_get_intfdata(intf);
dbgvm("vmk80xx: %s\n", __func__);
if (!dev)
return;
comedi_usb_auto_unconfig(dev->udev);
mutex_lock(&glb_mutex);
down(&dev->limit_sem);
dev->probed = 0;
usb_set_intfdata(dev->intf, NULL);
usb_kill_anchored_urbs(&dev->rx_anchor);
usb_kill_anchored_urbs(&dev->tx_anchor);
kfree(dev->usb_rx_buf);
kfree(dev->usb_tx_buf);
printk(KERN_INFO "comedi#: vmk80xx: board #%d [%s] now detached\n",
dev->count, dev->board.name);
up(&dev->limit_sem);
mutex_unlock(&glb_mutex);
}
/* TODO: Add support for suspend, resume, pre_reset,
* post_reset and flush */
static struct usb_driver vmk80xx_driver = {
.name = "vmk80xx",
.probe = vmk80xx_probe,
.disconnect = vmk80xx_disconnect,
.id_table = vmk80xx_id_table
};
static struct comedi_driver driver_vmk80xx = {
.module = THIS_MODULE,
.driver_name = "vmk80xx",
.attach = vmk80xx_attach,
.detach = vmk80xx_detach
};
static int __init vmk80xx_init(void)
{
int retval;
printk(KERN_INFO "vmk80xx: version 0.8.01 "
"Manuel Gebele <forensixs@gmx.de>\n");
retval = comedi_driver_register(&driver_vmk80xx);
if (retval < 0)
return retval;
return usb_register(&vmk80xx_driver);
}
static void __exit vmk80xx_exit(void)
{
comedi_driver_unregister(&driver_vmk80xx);
usb_deregister(&vmk80xx_driver);
}
module_init(vmk80xx_init);
module_exit(vmk80xx_exit);
