__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,
+static const struct vmk80xx_board vmk80xx_boardinfo[] = {
+ [DEVICE_VMK8055] = {
+ .name = "K8055 (VM110)",
+ .model = VMK8055_MODEL,
+ .range = &vmk8055_range,
+ .ai_chans = 2,
+ .ai_bits = 8,
+ .ao_chans = 2,
+ .di_chans = 6,
+ .cnt_bits = 16,
+ .pwm_chans = 0,
+ .pwm_bits = 0,
+ },
+ [DEVICE_VMK8061] = {
+ .name = "K8061 (VM140)",
+ .model = VMK8061_MODEL,
+ .range = &vmk8061_range,
+ .ai_chans = 8,
+ .ai_bits = 10,
+ .ao_chans = 8,
+ .di_chans = 8,
+ .cnt_bits = 0,
+ .pwm_chans = 1,
+ .pwm_bits = 10,
+ },
};
-struct vmk80xx_usb {
- struct usb_device *udev;
+struct vmk80xx_private {
+ struct usb_device *usb;
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;
+ const struct vmk80xx_board *board;
struct firmware_version fw;
struct semaphore limit_sem;
wait_queue_head_t read_wait;
int count;
};
-static struct vmk80xx_usb vmb[VMK80XX_MAX_BOARDS];
+static struct vmk80xx_private vmb[VMK80XX_MAX_BOARDS];
static DEFINE_MUTEX(glb_mutex);
static void vmk80xx_tx_callback(struct urb *urb)
{
- struct vmk80xx_usb *dev = urb->context;
+ struct vmk80xx_private *devpriv = urb->context;
+ unsigned long *flags = &devpriv->flags;
int stat = urb->status;
if (stat && !(stat == -ENOENT
dbgcm("comedi#: vmk80xx: %s - nonzero urb status (%d)\n",
__func__, stat);
- if (!test_bit(TRANS_OUT_BUSY, &dev->flags))
+ if (!test_bit(TRANS_OUT_BUSY, flags))
return;
- clear_bit(TRANS_OUT_BUSY, &dev->flags);
+ clear_bit(TRANS_OUT_BUSY, flags);
- wake_up_interruptible(&dev->write_wait);
+ wake_up_interruptible(&devpriv->write_wait);
}
static void vmk80xx_rx_callback(struct urb *urb)
{
- struct vmk80xx_usb *dev = urb->context;
+ struct vmk80xx_private *devpriv = urb->context;
+ unsigned long *flags = &devpriv->flags;
int stat = urb->status;
switch (stat) {
goto exit;
resubmit:
- if (test_bit(TRANS_IN_RUNNING, &dev->flags) && dev->intf) {
- usb_anchor_urb(urb, &dev->rx_anchor);
+ if (test_bit(TRANS_IN_RUNNING, flags) && devpriv->intf) {
+ usb_anchor_urb(urb, &devpriv->rx_anchor);
if (!usb_submit_urb(urb, GFP_KERNEL))
goto exit;
usb_unanchor_urb(urb);
}
exit:
- clear_bit(TRANS_IN_BUSY, &dev->flags);
+ clear_bit(TRANS_IN_BUSY, flags);
- wake_up_interruptible(&dev->read_wait);
+ wake_up_interruptible(&devpriv->read_wait);
}
-static int vmk80xx_check_data_link(struct vmk80xx_usb *dev)
+static int vmk80xx_check_data_link(struct vmk80xx_private *devpriv)
{
+ struct usb_device *usb = devpriv->usb;
unsigned int tx_pipe;
unsigned int rx_pipe;
unsigned char tx[1];
unsigned char rx[2];
- tx_pipe = usb_sndbulkpipe(dev->udev, 0x01);
- rx_pipe = usb_rcvbulkpipe(dev->udev, 0x81);
+ tx_pipe = usb_sndbulkpipe(usb, 0x01);
+ rx_pipe = usb_rcvbulkpipe(usb, 0x81);
tx[0] = VMK8061_CMD_RD_PWR_STAT;
* 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);
+ usb_bulk_msg(usb, tx_pipe, tx, 1, NULL, devpriv->ep_tx->bInterval);
+ usb_bulk_msg(usb, rx_pipe, rx, 2, NULL, HZ * 10);
return (int)rx[1];
}
-static void vmk80xx_read_eeprom(struct vmk80xx_usb *dev, int flag)
+static void vmk80xx_read_eeprom(struct vmk80xx_private *devpriv, int flag)
{
+ struct usb_device *usb = devpriv->usb;
unsigned int tx_pipe;
unsigned int rx_pipe;
unsigned char tx[1];
unsigned char rx[64];
int cnt;
- tx_pipe = usb_sndbulkpipe(dev->udev, 0x01);
- rx_pipe = usb_rcvbulkpipe(dev->udev, 0x81);
+ tx_pipe = usb_sndbulkpipe(usb, 0x01);
+ rx_pipe = usb_rcvbulkpipe(usb, 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);
+ usb_bulk_msg(usb, tx_pipe, tx, 1, NULL, devpriv->ep_tx->bInterval);
+ usb_bulk_msg(usb, rx_pipe, rx, 64, &cnt, HZ * 10);
rx[cnt] = '\0';
if (flag & IC3_VERSION)
- strncpy(dev->fw.ic3_vers, rx + 1, 24);
+ strncpy(devpriv->fw.ic3_vers, rx + 1, 24);
else /* IC6_VERSION */
- strncpy(dev->fw.ic6_vers, rx + 25, 24);
+ strncpy(devpriv->fw.ic6_vers, rx + 25, 24);
}
-static int vmk80xx_reset_device(struct vmk80xx_usb *dev)
+static int vmk80xx_reset_device(struct vmk80xx_private *devpriv)
{
+ struct usb_device *usb = devpriv->usb;
+ unsigned char *tx_buf = devpriv->usb_tx_buf;
struct urb *urb;
unsigned int tx_pipe;
int ival;
if (!urb)
return -ENOMEM;
- tx_pipe = usb_sndintpipe(dev->udev, 0x01);
+ tx_pipe = usb_sndintpipe(usb, 0x01);
- ival = dev->ep_tx->bInterval;
- size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
+ ival = devpriv->ep_tx->bInterval;
+ size = le16_to_cpu(devpriv->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;
+ tx_buf[0] = VMK8055_CMD_RST;
+ tx_buf[1] = 0x00;
+ tx_buf[2] = 0x00;
+ tx_buf[3] = 0x00;
+ tx_buf[4] = 0x00;
+ tx_buf[5] = 0x00;
+ tx_buf[6] = 0x00;
+ tx_buf[7] = 0x00;
- usb_fill_int_urb(urb, dev->udev, tx_pipe, dev->usb_tx_buf,
- size, vmk80xx_tx_callback, dev, ival);
+ usb_fill_int_urb(urb, usb, tx_pipe, tx_buf, size,
+ vmk80xx_tx_callback, devpriv, ival);
- usb_anchor_urb(urb, &dev->tx_anchor);
+ usb_anchor_urb(urb, &devpriv->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;
+ struct vmk80xx_private *devpriv = urb->context;
+ struct usb_device *usb = devpriv->usb;
__u8 rx_addr;
__u8 tx_addr;
unsigned int pipe;
int ival;
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);
+ rx_addr = devpriv->ep_rx->bEndpointAddress;
+ pipe = usb_rcvintpipe(usb, rx_addr);
+ buf = devpriv->usb_rx_buf;
+ size = le16_to_cpu(devpriv->ep_rx->wMaxPacketSize);
callback = vmk80xx_rx_callback;
- ival = dev->ep_rx->bInterval;
+ ival = devpriv->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);
+ tx_addr = devpriv->ep_tx->bEndpointAddress;
+ pipe = usb_sndintpipe(usb, tx_addr);
+ buf = devpriv->usb_tx_buf;
+ size = le16_to_cpu(devpriv->ep_tx->wMaxPacketSize);
callback = vmk80xx_tx_callback;
- ival = dev->ep_tx->bInterval;
+ ival = devpriv->ep_tx->bInterval;
}
- usb_fill_int_urb(urb, dev->udev, pipe, buf, size, callback, dev, ival);
+ usb_fill_int_urb(urb, usb, pipe, buf, size, callback, devpriv, ival);
}
-static void vmk80xx_do_bulk_msg(struct vmk80xx_usb *dev)
+static void vmk80xx_do_bulk_msg(struct vmk80xx_private *devpriv)
{
+ struct usb_device *usb = devpriv->usb;
+ unsigned long *flags = &devpriv->flags;
__u8 tx_addr;
__u8 rx_addr;
unsigned int tx_pipe;
unsigned int rx_pipe;
size_t size;
- set_bit(TRANS_IN_BUSY, &dev->flags);
- set_bit(TRANS_OUT_BUSY, &dev->flags);
+ set_bit(TRANS_IN_BUSY, flags);
+ set_bit(TRANS_OUT_BUSY, 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);
+ tx_addr = devpriv->ep_tx->bEndpointAddress;
+ rx_addr = devpriv->ep_rx->bEndpointAddress;
+ tx_pipe = usb_sndbulkpipe(usb, tx_addr);
+ rx_pipe = usb_rcvbulkpipe(usb, rx_addr);
/*
* The max packet size attributes of the K8061
* input/output endpoints are identical
*/
- size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
+ size = le16_to_cpu(devpriv->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);
+ usb_bulk_msg(usb, tx_pipe, devpriv->usb_tx_buf,
+ size, NULL, devpriv->ep_tx->bInterval);
+ usb_bulk_msg(usb, rx_pipe, devpriv->usb_rx_buf, size, NULL, HZ * 10);
- clear_bit(TRANS_OUT_BUSY, &dev->flags);
- clear_bit(TRANS_IN_BUSY, &dev->flags);
+ clear_bit(TRANS_OUT_BUSY, flags);
+ clear_bit(TRANS_IN_BUSY, flags);
}
-static int vmk80xx_read_packet(struct vmk80xx_usb *dev)
+static int vmk80xx_read_packet(struct vmk80xx_private *devpriv)
{
+ const struct vmk80xx_board *boardinfo = devpriv->board;
+ unsigned long *flags = &devpriv->flags;
struct urb *urb;
int retval;
- if (!dev->intf)
+ if (!devpriv->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)))
+ if (test_bit(TRANS_IN_BUSY, flags))
+ if (wait_event_interruptible(devpriv->read_wait,
+ !test_bit(TRANS_IN_BUSY, flags)))
return -ERESTART;
- if (dev->board.model == VMK8061_MODEL) {
- vmk80xx_do_bulk_msg(dev);
+ if (boardinfo->model == VMK8061_MODEL) {
+ vmk80xx_do_bulk_msg(devpriv);
return 0;
}
if (!urb)
return -ENOMEM;
- urb->context = dev;
+ urb->context = devpriv;
vmk80xx_build_int_urb(urb, URB_RCV_FLAG);
- set_bit(TRANS_IN_RUNNING, &dev->flags);
- set_bit(TRANS_IN_BUSY, &dev->flags);
+ set_bit(TRANS_IN_RUNNING, flags);
+ set_bit(TRANS_IN_BUSY, flags);
- usb_anchor_urb(urb, &dev->rx_anchor);
+ usb_anchor_urb(urb, &devpriv->rx_anchor);
retval = usb_submit_urb(urb, GFP_KERNEL);
if (!retval)
goto exit;
- clear_bit(TRANS_IN_RUNNING, &dev->flags);
+ clear_bit(TRANS_IN_RUNNING, flags);
usb_unanchor_urb(urb);
exit:
return retval;
}
-static int vmk80xx_write_packet(struct vmk80xx_usb *dev, int cmd)
+static int vmk80xx_write_packet(struct vmk80xx_private *devpriv, int cmd)
{
+ const struct vmk80xx_board *boardinfo = devpriv->board;
+ unsigned long *flags = &devpriv->flags;
struct urb *urb;
int retval;
- if (!dev->intf)
+ if (!devpriv->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)))
+ if (test_bit(TRANS_OUT_BUSY, flags))
+ if (wait_event_interruptible(devpriv->write_wait,
+ !test_bit(TRANS_OUT_BUSY, flags)))
return -ERESTART;
- if (dev->board.model == VMK8061_MODEL) {
- dev->usb_tx_buf[0] = cmd;
- vmk80xx_do_bulk_msg(dev);
+ if (boardinfo->model == VMK8061_MODEL) {
+ devpriv->usb_tx_buf[0] = cmd;
+ vmk80xx_do_bulk_msg(devpriv);
return 0;
}
if (!urb)
return -ENOMEM;
- urb->context = dev;
+ urb->context = devpriv;
vmk80xx_build_int_urb(urb, URB_SND_FLAG);
- set_bit(TRANS_OUT_BUSY, &dev->flags);
+ set_bit(TRANS_OUT_BUSY, flags);
- usb_anchor_urb(urb, &dev->tx_anchor);
+ usb_anchor_urb(urb, &devpriv->tx_anchor);
- dev->usb_tx_buf[0] = cmd;
+ devpriv->usb_tx_buf[0] = cmd;
retval = usb_submit_urb(urb, GFP_KERNEL);
if (!retval)
goto exit;
- clear_bit(TRANS_OUT_BUSY, &dev->flags);
+ clear_bit(TRANS_OUT_BUSY, flags);
usb_unanchor_urb(urb);
exit:
#define DIR_IN 1
#define DIR_OUT 2
-static int rudimentary_check(struct vmk80xx_usb *dev, int dir)
+static int rudimentary_check(struct vmk80xx_private *devpriv, int dir)
{
- if (!dev)
+ if (!devpriv)
return -EFAULT;
- if (!dev->probed)
+ if (!devpriv->probed)
return -ENODEV;
- if (!dev->attached)
+ if (!devpriv->attached)
return -ENODEV;
if (dir & DIR_IN) {
- if (test_bit(TRANS_IN_BUSY, &dev->flags))
+ if (test_bit(TRANS_IN_BUSY, &devpriv->flags))
return -EBUSY;
}
if (dir & DIR_OUT) {
- if (test_bit(TRANS_OUT_BUSY, &dev->flags))
+ if (test_bit(TRANS_OUT_BUSY, &devpriv->flags))
return -EBUSY;
}
return 0;
}
-static int vmk80xx_ai_rinsn(struct comedi_device *cdev,
+static int vmk80xx_ai_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
int chan;
int reg[2];
int n;
- n = rudimentary_check(dev, DIR_IN);
+ n = rudimentary_check(devpriv, DIR_IN);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
- switch (dev->board.model) {
+ switch (boardinfo->model) {
case VMK8055_MODEL:
if (!chan)
reg[0] = VMK8055_AI1_REG;
default:
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;
+ devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_AI;
+ devpriv->usb_tx_buf[VMK8061_CH_REG] = chan;
break;
}
for (n = 0; n < insn->n; n++) {
- if (vmk80xx_read_packet(dev))
+ if (vmk80xx_read_packet(devpriv))
break;
- if (dev->board.model == VMK8055_MODEL) {
- data[n] = dev->usb_rx_buf[reg[0]];
+ if (boardinfo->model == VMK8055_MODEL) {
+ data[n] = devpriv->usb_rx_buf[reg[0]];
continue;
}
/* VMK8061_MODEL */
- data[n] = dev->usb_rx_buf[reg[0]] + 256 *
- dev->usb_rx_buf[reg[1]];
+ data[n] = devpriv->usb_rx_buf[reg[0]] + 256 *
+ devpriv->usb_rx_buf[reg[1]];
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_ao_winsn(struct comedi_device *cdev,
+static int vmk80xx_ao_winsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
int chan;
int cmd;
int reg;
int n;
- n = rudimentary_check(dev, DIR_OUT);
+ n = rudimentary_check(devpriv, DIR_OUT);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
- switch (dev->board.model) {
+ switch (boardinfo->model) {
case VMK8055_MODEL:
cmd = VMK8055_CMD_WRT_AD;
if (!chan)
default: /* NOTE: avoid compiler warnings */
cmd = VMK8061_CMD_SET_AO;
reg = VMK8061_AO_REG;
- dev->usb_tx_buf[VMK8061_CH_REG] = chan;
+ devpriv->usb_tx_buf[VMK8061_CH_REG] = chan;
break;
}
for (n = 0; n < insn->n; n++) {
- dev->usb_tx_buf[reg] = data[n];
+ devpriv->usb_tx_buf[reg] = data[n];
- if (vmk80xx_write_packet(dev, cmd))
+ if (vmk80xx_write_packet(devpriv, cmd))
break;
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_ao_rinsn(struct comedi_device *cdev,
+static int vmk80xx_ao_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ struct vmk80xx_private *devpriv = dev->private;
int chan;
int reg;
int n;
- n = rudimentary_check(dev, DIR_IN);
+ n = rudimentary_check(devpriv, DIR_IN);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
reg = VMK8061_AO_REG - 1;
- dev->usb_tx_buf[0] = VMK8061_CMD_RD_AO;
+ devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_AO;
for (n = 0; n < insn->n; n++) {
- if (vmk80xx_read_packet(dev))
+ if (vmk80xx_read_packet(devpriv))
break;
- data[n] = dev->usb_rx_buf[reg + chan];
+ data[n] = devpriv->usb_rx_buf[reg + chan];
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_di_bits(struct comedi_device *cdev,
+static int vmk80xx_di_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
unsigned char *rx_buf;
int reg;
int retval;
- retval = rudimentary_check(dev, DIR_IN);
+ retval = rudimentary_check(devpriv, DIR_IN);
if (retval)
return retval;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
- rx_buf = dev->usb_rx_buf;
+ rx_buf = devpriv->usb_rx_buf;
- if (dev->board.model == VMK8061_MODEL) {
+ if (boardinfo->model == VMK8061_MODEL) {
reg = VMK8061_DI_REG;
- dev->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
+ devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
} else {
reg = VMK8055_DI_REG;
}
- retval = vmk80xx_read_packet(dev);
+ retval = vmk80xx_read_packet(devpriv);
if (!retval) {
- if (dev->board.model == VMK8055_MODEL)
+ if (boardinfo->model == VMK8055_MODEL)
data[1] = (((rx_buf[reg] >> 4) & 0x03) |
((rx_buf[reg] << 2) & 0x04) |
((rx_buf[reg] >> 3) & 0x18));
retval = 2;
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return retval;
}
-static int vmk80xx_di_rinsn(struct comedi_device *cdev,
+static int vmk80xx_di_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
int chan;
unsigned char *rx_buf;
int reg;
int inp;
int n;
- n = rudimentary_check(dev, DIR_IN);
+ n = rudimentary_check(devpriv, DIR_IN);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
- rx_buf = dev->usb_rx_buf;
+ rx_buf = devpriv->usb_rx_buf;
- if (dev->board.model == VMK8061_MODEL) {
+ if (boardinfo->model == VMK8061_MODEL) {
reg = VMK8061_DI_REG;
- dev->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
+ devpriv->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))
+ if (vmk80xx_read_packet(devpriv))
break;
- if (dev->board.model == VMK8055_MODEL)
+ if (boardinfo->model == VMK8055_MODEL)
inp = (((rx_buf[reg] >> 4) & 0x03) |
((rx_buf[reg] << 2) & 0x04) |
((rx_buf[reg] >> 3) & 0x18));
data[n] = (inp >> chan) & 1;
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_do_winsn(struct comedi_device *cdev,
+static int vmk80xx_do_winsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
int chan;
unsigned char *tx_buf;
int reg;
int cmd;
int n;
- n = rudimentary_check(dev, DIR_OUT);
+ n = rudimentary_check(devpriv, DIR_OUT);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
- tx_buf = dev->usb_tx_buf;
+ tx_buf = devpriv->usb_tx_buf;
for (n = 0; n < insn->n; n++) {
- if (dev->board.model == VMK8055_MODEL) {
+ if (boardinfo->model == VMK8055_MODEL) {
reg = VMK8055_DO_REG;
cmd = VMK8055_CMD_WRT_AD;
if (data[n] == 1)
}
}
- if (vmk80xx_write_packet(dev, cmd))
+ if (vmk80xx_write_packet(devpriv, cmd))
break;
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_do_rinsn(struct comedi_device *cdev,
+static int vmk80xx_do_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ struct vmk80xx_private *devpriv = dev->private;
int chan;
int reg;
int n;
- n = rudimentary_check(dev, DIR_IN);
+ n = rudimentary_check(devpriv, DIR_IN);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
reg = VMK8061_DO_REG;
- dev->usb_tx_buf[0] = VMK8061_CMD_RD_DO;
+ devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_DO;
for (n = 0; n < insn->n; n++) {
- if (vmk80xx_read_packet(dev))
+ if (vmk80xx_read_packet(devpriv))
break;
- data[n] = (dev->usb_rx_buf[reg] >> chan) & 1;
+ data[n] = (devpriv->usb_rx_buf[reg] >> chan) & 1;
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_do_bits(struct comedi_device *cdev,
+static int vmk80xx_do_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
unsigned char *rx_buf, *tx_buf;
int dir, reg, cmd;
int retval;
if (data[0])
dir |= DIR_OUT;
- if (dev->board.model == VMK8061_MODEL)
+ if (boardinfo->model == VMK8061_MODEL)
dir |= DIR_IN;
- retval = rudimentary_check(dev, dir);
+ retval = rudimentary_check(devpriv, dir);
if (retval)
return retval;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
- rx_buf = dev->usb_rx_buf;
- tx_buf = dev->usb_tx_buf;
+ rx_buf = devpriv->usb_rx_buf;
+ tx_buf = devpriv->usb_tx_buf;
if (data[0]) {
- if (dev->board.model == VMK8055_MODEL) {
+ if (boardinfo->model == VMK8055_MODEL) {
reg = VMK8055_DO_REG;
cmd = VMK8055_CMD_WRT_AD;
} else { /* VMK8061_MODEL */
tx_buf[reg] &= ~data[0];
tx_buf[reg] |= (data[0] & data[1]);
- retval = vmk80xx_write_packet(dev, cmd);
+ retval = vmk80xx_write_packet(devpriv, cmd);
if (retval)
goto out;
}
- if (dev->board.model == VMK8061_MODEL) {
+ if (boardinfo->model == VMK8061_MODEL) {
reg = VMK8061_DO_REG;
tx_buf[0] = VMK8061_CMD_RD_DO;
- retval = vmk80xx_read_packet(dev);
+ retval = vmk80xx_read_packet(devpriv);
if (!retval) {
data[1] = rx_buf[reg];
}
out:
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return retval;
}
-static int vmk80xx_cnt_rinsn(struct comedi_device *cdev,
+static int vmk80xx_cnt_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
int chan;
int reg[2];
int n;
- n = rudimentary_check(dev, DIR_IN);
+ n = rudimentary_check(devpriv, DIR_IN);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
- switch (dev->board.model) {
+ switch (boardinfo->model) {
case VMK8055_MODEL:
if (!chan)
reg[0] = VMK8055_CNT1_REG;
default:
reg[0] = VMK8061_CNT_REG;
reg[1] = VMK8061_CNT_REG;
- dev->usb_tx_buf[0] = VMK8061_CMD_RD_CNT;
+ devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_CNT;
break;
}
for (n = 0; n < insn->n; n++) {
- if (vmk80xx_read_packet(dev))
+ if (vmk80xx_read_packet(devpriv))
break;
- if (dev->board.model == VMK8055_MODEL)
- data[n] = dev->usb_rx_buf[reg[0]];
+ if (boardinfo->model == VMK8055_MODEL)
+ data[n] = devpriv->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];
+ data[n] = devpriv->usb_rx_buf[reg[0] * (chan + 1) + 1]
+ + 256 * devpriv->usb_rx_buf[reg[1] * 2 + 2];
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_cnt_cinsn(struct comedi_device *cdev,
+static int vmk80xx_cnt_cinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ const struct vmk80xx_board *boardinfo = comedi_board(dev);
+ struct vmk80xx_private *devpriv = dev->private;
unsigned int insn_cmd;
int chan;
int cmd;
int reg;
int n;
- n = rudimentary_check(dev, DIR_OUT);
+ n = rudimentary_check(devpriv, DIR_OUT);
if (n)
return n;
if (insn_cmd != INSN_CONFIG_RESET && insn_cmd != GPCT_RESET)
return -EINVAL;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
- if (dev->board.model == VMK8055_MODEL) {
+ if (boardinfo->model == VMK8055_MODEL) {
if (!chan) {
cmd = VMK8055_CMD_RST_CNT1;
reg = VMK8055_CNT1_REG;
reg = VMK8055_CNT2_REG;
}
- dev->usb_tx_buf[reg] = 0x00;
+ devpriv->usb_tx_buf[reg] = 0x00;
} else {
cmd = VMK8061_CMD_RST_CNT;
}
for (n = 0; n < insn->n; n++)
- if (vmk80xx_write_packet(dev, cmd))
+ if (vmk80xx_write_packet(devpriv, cmd))
break;
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_cnt_winsn(struct comedi_device *cdev,
+static int vmk80xx_cnt_winsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ struct vmk80xx_private *devpriv = dev->private;
unsigned long debtime;
unsigned long val;
int chan;
int cmd;
int n;
- n = rudimentary_check(dev, DIR_OUT);
+ n = rudimentary_check(devpriv, DIR_OUT);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
chan = CR_CHAN(insn->chanspec);
if (!chan)
if (((val + 1) * val) < debtime * 1000 / 115)
val += 1;
- dev->usb_tx_buf[6 + chan] = val;
+ devpriv->usb_tx_buf[6 + chan] = val;
- if (vmk80xx_write_packet(dev, cmd))
+ if (vmk80xx_write_packet(devpriv, cmd))
break;
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_pwm_rinsn(struct comedi_device *cdev,
+static int vmk80xx_pwm_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ struct vmk80xx_private *devpriv = dev->private;
+ unsigned char *tx_buf;
+ unsigned char *rx_buf;
int reg[2];
int n;
- n = rudimentary_check(dev, DIR_IN);
+ n = rudimentary_check(devpriv, DIR_IN);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
+
+ tx_buf = devpriv->usb_tx_buf;
+ rx_buf = devpriv->usb_rx_buf;
reg[0] = VMK8061_PWM_REG1;
reg[1] = VMK8061_PWM_REG2;
- dev->usb_tx_buf[0] = VMK8061_CMD_RD_PWM;
+ tx_buf[0] = VMK8061_CMD_RD_PWM;
for (n = 0; n < insn->n; n++) {
- if (vmk80xx_read_packet(dev))
+ if (vmk80xx_read_packet(devpriv))
break;
- data[n] = dev->usb_rx_buf[reg[0]] + 4 * dev->usb_rx_buf[reg[1]];
+ data[n] = rx_buf[reg[0]] + 4 * rx_buf[reg[1]];
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_pwm_winsn(struct comedi_device *cdev,
+static int vmk80xx_pwm_winsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- struct vmk80xx_usb *dev = cdev->private;
+ struct vmk80xx_private *devpriv = dev->private;
unsigned char *tx_buf;
int reg[2];
int cmd;
int n;
- n = rudimentary_check(dev, DIR_OUT);
+ n = rudimentary_check(devpriv, DIR_OUT);
if (n)
return n;
- down(&dev->limit_sem);
+ down(&devpriv->limit_sem);
- tx_buf = dev->usb_tx_buf;
+ tx_buf = devpriv->usb_tx_buf;
reg[0] = VMK8061_PWM_REG1;
reg[1] = VMK8061_PWM_REG2;
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))
+ if (vmk80xx_write_packet(devpriv, cmd))
break;
}
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return n;
}
-static int vmk80xx_attach_common(struct comedi_device *cdev,
- struct vmk80xx_usb *dev)
+static int vmk80xx_find_usb_endpoints(struct vmk80xx_private *devpriv,
+ struct usb_interface *intf)
+{
+ struct usb_host_interface *iface_desc = intf->cur_altsetting;
+ struct usb_endpoint_descriptor *ep_desc;
+ int i;
+
+ if (iface_desc->desc.bNumEndpoints != 2)
+ return -ENODEV;
+
+ for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
+ ep_desc = &iface_desc->endpoint[i].desc;
+
+ if (usb_endpoint_is_int_in(ep_desc) ||
+ usb_endpoint_is_bulk_in(ep_desc)) {
+ if (!devpriv->ep_rx)
+ devpriv->ep_rx = ep_desc;
+ continue;
+ }
+
+ if (usb_endpoint_is_int_out(ep_desc) ||
+ usb_endpoint_is_bulk_out(ep_desc)) {
+ if (!devpriv->ep_tx)
+ devpriv->ep_tx = ep_desc;
+ continue;
+ }
+ }
+
+ if (!devpriv->ep_rx || !devpriv->ep_tx)
+ return -ENODEV;
+
+ return 0;
+}
+
+static int vmk80xx_alloc_usb_buffers(struct vmk80xx_private *devpriv)
{
+ size_t size;
+
+ size = le16_to_cpu(devpriv->ep_rx->wMaxPacketSize);
+ devpriv->usb_rx_buf = kmalloc(size, GFP_KERNEL);
+ if (!devpriv->usb_rx_buf)
+ return -ENOMEM;
+
+ size = le16_to_cpu(devpriv->ep_tx->wMaxPacketSize);
+ devpriv->usb_tx_buf = kmalloc(size, GFP_KERNEL);
+ if (!devpriv->usb_tx_buf) {
+ kfree(devpriv->usb_rx_buf);
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+static int vmk80xx_attach_common(struct comedi_device *dev,
+ struct vmk80xx_private *devpriv)
+{
+ const struct vmk80xx_board *boardinfo;
int n_subd;
struct comedi_subdevice *s;
int ret;
- down(&dev->limit_sem);
- cdev->board_name = dev->board.name;
- cdev->private = dev;
- if (dev->board.model == VMK8055_MODEL)
+ down(&devpriv->limit_sem);
+
+ boardinfo = devpriv->board;
+ dev->board_ptr = boardinfo;
+ dev->board_name = boardinfo->name;
+ dev->private = devpriv;
+
+ if (boardinfo->model == VMK8055_MODEL)
n_subd = 5;
else
n_subd = 6;
- ret = comedi_alloc_subdevices(cdev, n_subd);
+ ret = comedi_alloc_subdevices(dev, n_subd);
if (ret) {
- up(&dev->limit_sem);
+ up(&devpriv->limit_sem);
return ret;
}
+
/* Analog input subdevice */
- s = &cdev->subdevices[VMK80XX_SUBD_AI];
+ s = &dev->subdevices[0];
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->n_chan = boardinfo->ai_chans;
+ s->maxdata = (1 << boardinfo->ai_bits) - 1;
+ s->range_table = boardinfo->range;
s->insn_read = vmk80xx_ai_rinsn;
+
/* Analog output subdevice */
- s = &cdev->subdevices[VMK80XX_SUBD_AO];
+ s = &dev->subdevices[1];
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->n_chan = boardinfo->ao_chans;
+ s->maxdata = 0x00ff;
+ s->range_table = boardinfo->range;
s->insn_write = vmk80xx_ao_winsn;
- if (dev->board.model == VMK8061_MODEL) {
+ if (boardinfo->model == VMK8061_MODEL) {
s->subdev_flags |= SDF_READABLE;
s->insn_read = vmk80xx_ao_rinsn;
}
+
/* Digital input subdevice */
- s = &cdev->subdevices[VMK80XX_SUBD_DI];
+ s = &dev->subdevices[2];
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
- s->n_chan = dev->board.di_chans;
+ s->n_chan = boardinfo->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 = &dev->subdevices[3];
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITEABLE | SDF_GROUND;
- s->n_chan = dev->board.do_chans;
+ s->n_chan = 8;
s->maxdata = 1;
s->insn_write = vmk80xx_do_winsn;
s->insn_bits = vmk80xx_do_bits;
- if (dev->board.model == VMK8061_MODEL) {
+ if (boardinfo->model == VMK8061_MODEL) {
s->subdev_flags |= SDF_READABLE;
s->insn_read = vmk80xx_do_rinsn;
}
+
/* Counter subdevice */
- s = &cdev->subdevices[VMK80XX_SUBD_CNT];
+ s = &dev->subdevices[4];
s->type = COMEDI_SUBD_COUNTER;
s->subdev_flags = SDF_READABLE;
- s->n_chan = dev->board.cnt_chans;
+ s->n_chan = 2;
s->insn_read = vmk80xx_cnt_rinsn;
s->insn_config = vmk80xx_cnt_cinsn;
- if (dev->board.model == VMK8055_MODEL) {
+ if (boardinfo->model == VMK8055_MODEL) {
s->subdev_flags |= SDF_WRITEABLE;
- s->maxdata = (1 << dev->board.cnt_bits) - 1;
+ s->maxdata = (1 << boardinfo->cnt_bits) - 1;
s->insn_write = vmk80xx_cnt_winsn;
}
+
/* PWM subdevice */
- if (dev->board.model == VMK8061_MODEL) {
- s = &cdev->subdevices[VMK80XX_SUBD_PWM];
+ if (boardinfo->model == VMK8061_MODEL) {
+ s = &dev->subdevices[5];
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->n_chan = boardinfo->pwm_chans;
+ s->maxdata = (1 << boardinfo->pwm_bits) - 1;
s->insn_read = vmk80xx_pwm_rinsn;
s->insn_write = vmk80xx_pwm_winsn;
}
- dev->attached = 1;
- dev_info(cdev->class_dev, "vmk80xx: board #%d [%s] attached\n",
- dev->count, dev->board.name);
- up(&dev->limit_sem);
- return 0;
-}
-/* called for COMEDI_DEVCONFIG ioctl for board_name "vmk80xx" */
-static int vmk80xx_attach(struct comedi_device *cdev,
- struct comedi_devconfig *it)
-{
- int i;
- int ret;
+ devpriv->attached = 1;
+ dev_info(dev->class_dev, "vmk80xx: board #%d [%s] attached\n",
+ devpriv->count, boardinfo->name);
- 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)
- ret = -ENODEV;
- else
- ret = vmk80xx_attach_common(cdev, &vmb[i]);
- mutex_unlock(&glb_mutex);
- return ret;
+ up(&devpriv->limit_sem);
+
+ return 0;
}
-/* called via comedi_usb_auto_config() */
-static int vmk80xx_auto_attach(struct comedi_device *cdev,
+static int vmk80xx_auto_attach(struct comedi_device *dev,
unsigned long context_unused)
{
- struct usb_interface *intf = comedi_to_usb_interface(cdev);
+ struct usb_interface *intf = comedi_to_usb_interface(dev);
int i;
int ret;
else if (vmb[i].attached)
ret = -EBUSY;
else
- ret = vmk80xx_attach_common(cdev, &vmb[i]);
+ ret = vmk80xx_attach_common(dev, &vmb[i]);
mutex_unlock(&glb_mutex);
return ret;
}
static void vmk80xx_detach(struct comedi_device *dev)
{
- struct vmk80xx_usb *usb = dev->private;
+ struct vmk80xx_private *devpriv = dev->private;
- if (usb) {
- down(&usb->limit_sem);
- dev->private = NULL;
- usb->attached = 0;
- up(&usb->limit_sem);
- }
+ if (!devpriv)
+ return;
+
+ mutex_lock(&glb_mutex);
+ down(&devpriv->limit_sem);
+
+ dev->private = NULL;
+
+ devpriv->attached = 0;
+ devpriv->probed = 0;
+ usb_set_intfdata(devpriv->intf, NULL);
+
+ usb_kill_anchored_urbs(&devpriv->rx_anchor);
+ usb_kill_anchored_urbs(&devpriv->tx_anchor);
+
+ kfree(devpriv->usb_rx_buf);
+ kfree(devpriv->usb_tx_buf);
+
+ up(&devpriv->limit_sem);
+ mutex_unlock(&glb_mutex);
}
static struct comedi_driver vmk80xx_driver = {
.module = THIS_MODULE,
.driver_name = "vmk80xx",
- .attach = vmk80xx_attach,
- .detach = vmk80xx_detach,
.auto_attach = vmk80xx_auto_attach,
+ .detach = vmk80xx_detach,
};
static int vmk80xx_usb_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
+ const struct vmk80xx_board *boardinfo;
+ struct vmk80xx_private *devpriv;
+ int ret;
int i;
- struct vmk80xx_usb *dev;
- struct usb_host_interface *iface_desc;
- struct usb_endpoint_descriptor *ep_desc;
- size_t size;
mutex_lock(&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;
- }
- }
+ devpriv = &vmb[i];
- if (!dev->ep_rx || !dev->ep_tx)
- goto error;
+ memset(devpriv, 0x00, sizeof(*devpriv));
+ devpriv->count = i;
- size = le16_to_cpu(dev->ep_rx->wMaxPacketSize);
- dev->usb_rx_buf = kmalloc(size, GFP_KERNEL);
- if (!dev->usb_rx_buf) {
+ ret = vmk80xx_find_usb_endpoints(devpriv, intf);
+ if (ret) {
mutex_unlock(&glb_mutex);
- return -ENOMEM;
+ return ret;
}
- 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);
+ ret = vmk80xx_alloc_usb_buffers(devpriv);
+ if (ret) {
mutex_unlock(&glb_mutex);
- return -ENOMEM;
+ return ret;
}
- 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;
- }
+ devpriv->usb = interface_to_usbdev(intf);
+ devpriv->intf = intf;
+
+ sema_init(&devpriv->limit_sem, 8);
+ init_waitqueue_head(&devpriv->read_wait);
+ init_waitqueue_head(&devpriv->write_wait);
+
+ init_usb_anchor(&devpriv->rx_anchor);
+ init_usb_anchor(&devpriv->tx_anchor);
+
+ usb_set_intfdata(intf, devpriv);
- if (dev->board.model == VMK8061_MODEL) {
- vmk80xx_read_eeprom(dev, IC3_VERSION);
- dev_info(&intf->dev, "%s\n", dev->fw.ic3_vers);
+ boardinfo = &vmk80xx_boardinfo[id->driver_info];
+ devpriv->board = boardinfo;
- if (vmk80xx_check_data_link(dev)) {
- vmk80xx_read_eeprom(dev, IC6_VERSION);
- dev_info(&intf->dev, "%s\n", dev->fw.ic6_vers);
+ if (boardinfo->model == VMK8061_MODEL) {
+ vmk80xx_read_eeprom(devpriv, IC3_VERSION);
+ dev_info(&intf->dev, "%s\n", devpriv->fw.ic3_vers);
+
+ if (vmk80xx_check_data_link(devpriv)) {
+ vmk80xx_read_eeprom(devpriv, IC6_VERSION);
+ dev_info(&intf->dev, "%s\n", devpriv->fw.ic6_vers);
} else {
dbgcm("comedi#: vmk80xx: no conn. to CPU\n");
}
}
- if (dev->board.model == VMK8055_MODEL)
- vmk80xx_reset_device(dev);
+ if (boardinfo->model == VMK8055_MODEL)
+ vmk80xx_reset_device(devpriv);
- dev->probed = 1;
+ devpriv->probed = 1;
dev_info(&intf->dev, "board #%d [%s] now attached\n",
- dev->count, dev->board.name);
+ devpriv->count, boardinfo->name);
mutex_unlock(&glb_mutex);
comedi_usb_auto_config(intf, &vmk80xx_driver);
return 0;
-error:
- mutex_unlock(&glb_mutex);
-
- return -ENODEV;
-}
-
-static void vmk80xx_usb_disconnect(struct usb_interface *intf)
-{
- struct vmk80xx_usb *dev = usb_get_intfdata(intf);
-
- if (!dev)
- return;
-
- comedi_usb_auto_unconfig(intf);
-
- 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);
-
- dev_info(&intf->dev, "board #%d [%s] now detached\n",
- dev->count, dev->board.name);
-
- up(&dev->limit_sem);
- mutex_unlock(&glb_mutex);
}
static const struct usb_device_id vmk80xx_usb_id_table[] = {
};
MODULE_DEVICE_TABLE(usb, vmk80xx_usb_id_table);
-/* TODO: Add support for suspend, resume, pre_reset,
- * post_reset and flush */
static struct usb_driver vmk80xx_usb_driver = {
.name = "vmk80xx",
- .probe = vmk80xx_usb_probe,
- .disconnect = vmk80xx_usb_disconnect,
.id_table = vmk80xx_usb_id_table,
+ .probe = vmk80xx_usb_probe,
+ .disconnect = comedi_usb_auto_unconfig,
};
module_comedi_usb_driver(vmk80xx_driver, vmk80xx_usb_driver);
projects / firefly-linux-kernel-4.4.55.git / blobdiff