| // SPDX-License-Identifier: GPL-2.0+ |
| /* |
| * comedi/drivers/ni_usb6501.c |
| * Comedi driver for National Instruments USB-6501 |
| * |
| * COMEDI - Linux Control and Measurement Device Interface |
| * Copyright (C) 2014 Luca Ellero <luca.ellero@brickedbrain.com> |
| */ |
| |
| /* |
| * Driver: ni_usb6501 |
| * Description: National Instruments USB-6501 module |
| * Devices: [National Instruments] USB-6501 (ni_usb6501) |
| * Author: Luca Ellero <luca.ellero@brickedbrain.com> |
| * Updated: 8 Sep 2014 |
| * Status: works |
| * |
| * |
| * Configuration Options: |
| * none |
| */ |
| |
| /* |
| * NI-6501 - USB PROTOCOL DESCRIPTION |
| * |
| * Every command is composed by two USB packets: |
| * - request (out) |
| * - response (in) |
| * |
| * Every packet is at least 12 bytes long, here is the meaning of |
| * every field (all values are hex): |
| * |
| * byte 0 is always 00 |
| * byte 1 is always 01 |
| * byte 2 is always 00 |
| * byte 3 is the total packet length |
| * |
| * byte 4 is always 00 |
| * byte 5 is the total packet length - 4 |
| * byte 6 is always 01 |
| * byte 7 is the command |
| * |
| * byte 8 is 02 (request) or 00 (response) |
| * byte 9 is 00 (response) or 10 (port request) or 20 (counter request) |
| * byte 10 is always 00 |
| * byte 11 is 00 (request) or 02 (response) |
| * |
| * PORT PACKETS |
| * |
| * CMD: 0xE READ_PORT |
| * REQ: 00 01 00 10 00 0C 01 0E 02 10 00 00 00 03 <PORT> 00 |
| * RES: 00 01 00 10 00 0C 01 00 00 00 00 02 00 03 <BMAP> 00 |
| * |
| * CMD: 0xF WRITE_PORT |
| * REQ: 00 01 00 14 00 10 01 0F 02 10 00 00 00 03 <PORT> 00 03 <BMAP> 00 00 |
| * RES: 00 01 00 0C 00 08 01 00 00 00 00 02 |
| * |
| * CMD: 0x12 SET_PORT_DIR (0 = input, 1 = output) |
| * REQ: 00 01 00 18 00 14 01 12 02 10 00 00 |
| * 00 05 <PORT 0> <PORT 1> <PORT 2> 00 05 00 00 00 00 00 |
| * RES: 00 01 00 0C 00 08 01 00 00 00 00 02 |
| * |
| * COUNTER PACKETS |
| * |
| * CMD 0x9: START_COUNTER |
| * REQ: 00 01 00 0C 00 08 01 09 02 20 00 00 |
| * RES: 00 01 00 0C 00 08 01 00 00 00 00 02 |
| * |
| * CMD 0xC: STOP_COUNTER |
| * REQ: 00 01 00 0C 00 08 01 0C 02 20 00 00 |
| * RES: 00 01 00 0C 00 08 01 00 00 00 00 02 |
| * |
| * CMD 0xE: READ_COUNTER |
| * REQ: 00 01 00 0C 00 08 01 0E 02 20 00 00 |
| * RES: 00 01 00 10 00 0C 01 00 00 00 00 02 <u32 counter value, Big Endian> |
| * |
| * CMD 0xF: WRITE_COUNTER |
| * REQ: 00 01 00 10 00 0C 01 0F 02 20 00 00 <u32 counter value, Big Endian> |
| * RES: 00 01 00 0C 00 08 01 00 00 00 00 02 |
| * |
| * |
| * Please visit https://www.brickedbrain.com if you need |
| * additional information or have any questions. |
| * |
| */ |
| |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/slab.h> |
| |
| #include "../comedi_usb.h" |
| |
| #define NI6501_TIMEOUT 1000 |
| |
| /* Port request packets */ |
| static const u8 READ_PORT_REQUEST[] = {0x00, 0x01, 0x00, 0x10, |
| 0x00, 0x0C, 0x01, 0x0E, |
| 0x02, 0x10, 0x00, 0x00, |
| 0x00, 0x03, 0x00, 0x00}; |
| |
| static const u8 WRITE_PORT_REQUEST[] = {0x00, 0x01, 0x00, 0x14, |
| 0x00, 0x10, 0x01, 0x0F, |
| 0x02, 0x10, 0x00, 0x00, |
| 0x00, 0x03, 0x00, 0x00, |
| 0x03, 0x00, 0x00, 0x00}; |
| |
| static const u8 SET_PORT_DIR_REQUEST[] = {0x00, 0x01, 0x00, 0x18, |
| 0x00, 0x14, 0x01, 0x12, |
| 0x02, 0x10, 0x00, 0x00, |
| 0x00, 0x05, 0x00, 0x00, |
| 0x00, 0x00, 0x05, 0x00, |
| 0x00, 0x00, 0x00, 0x00}; |
| |
| /* Counter request packets */ |
| static const u8 START_COUNTER_REQUEST[] = {0x00, 0x01, 0x00, 0x0C, |
| 0x00, 0x08, 0x01, 0x09, |
| 0x02, 0x20, 0x00, 0x00}; |
| |
| static const u8 STOP_COUNTER_REQUEST[] = {0x00, 0x01, 0x00, 0x0C, |
| 0x00, 0x08, 0x01, 0x0C, |
| 0x02, 0x20, 0x00, 0x00}; |
| |
| static const u8 READ_COUNTER_REQUEST[] = {0x00, 0x01, 0x00, 0x0C, |
| 0x00, 0x08, 0x01, 0x0E, |
| 0x02, 0x20, 0x00, 0x00}; |
| |
| static const u8 WRITE_COUNTER_REQUEST[] = {0x00, 0x01, 0x00, 0x10, |
| 0x00, 0x0C, 0x01, 0x0F, |
| 0x02, 0x20, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x00}; |
| |
| /* Response packets */ |
| static const u8 GENERIC_RESPONSE[] = {0x00, 0x01, 0x00, 0x0C, |
| 0x00, 0x08, 0x01, 0x00, |
| 0x00, 0x00, 0x00, 0x02}; |
| |
| static const u8 READ_PORT_RESPONSE[] = {0x00, 0x01, 0x00, 0x10, |
| 0x00, 0x0C, 0x01, 0x00, |
| 0x00, 0x00, 0x00, 0x02, |
| 0x00, 0x03, 0x00, 0x00}; |
| |
| static const u8 READ_COUNTER_RESPONSE[] = {0x00, 0x01, 0x00, 0x10, |
| 0x00, 0x0C, 0x01, 0x00, |
| 0x00, 0x00, 0x00, 0x02, |
| 0x00, 0x00, 0x00, 0x00}; |
| |
| /* Largest supported packets */ |
| static const size_t TX_MAX_SIZE = sizeof(SET_PORT_DIR_REQUEST); |
| static const size_t RX_MAX_SIZE = sizeof(READ_PORT_RESPONSE); |
| |
| enum commands { |
| READ_PORT, |
| WRITE_PORT, |
| SET_PORT_DIR, |
| START_COUNTER, |
| STOP_COUNTER, |
| READ_COUNTER, |
| WRITE_COUNTER |
| }; |
| |
| struct ni6501_private { |
| struct usb_endpoint_descriptor *ep_rx; |
| struct usb_endpoint_descriptor *ep_tx; |
| struct mutex mut; |
| u8 *usb_rx_buf; |
| u8 *usb_tx_buf; |
| }; |
| |
| static int ni6501_port_command(struct comedi_device *dev, int command, |
| unsigned int val, u8 *bitmap) |
| { |
| struct usb_device *usb = comedi_to_usb_dev(dev); |
| struct ni6501_private *devpriv = dev->private; |
| int request_size, response_size; |
| u8 *tx = devpriv->usb_tx_buf; |
| int ret; |
| |
| if (command != SET_PORT_DIR && !bitmap) |
| return -EINVAL; |
| |
| mutex_lock(&devpriv->mut); |
| |
| switch (command) { |
| case READ_PORT: |
| request_size = sizeof(READ_PORT_REQUEST); |
| response_size = sizeof(READ_PORT_RESPONSE); |
| memcpy(tx, READ_PORT_REQUEST, request_size); |
| tx[14] = val & 0xff; |
| break; |
| case WRITE_PORT: |
| request_size = sizeof(WRITE_PORT_REQUEST); |
| response_size = sizeof(GENERIC_RESPONSE); |
| memcpy(tx, WRITE_PORT_REQUEST, request_size); |
| tx[14] = val & 0xff; |
| tx[17] = *bitmap; |
| break; |
| case SET_PORT_DIR: |
| request_size = sizeof(SET_PORT_DIR_REQUEST); |
| response_size = sizeof(GENERIC_RESPONSE); |
| memcpy(tx, SET_PORT_DIR_REQUEST, request_size); |
| tx[14] = val & 0xff; |
| tx[15] = (val >> 8) & 0xff; |
| tx[16] = (val >> 16) & 0xff; |
| break; |
| default: |
| ret = -EINVAL; |
| goto end; |
| } |
| |
| ret = usb_bulk_msg(usb, |
| usb_sndbulkpipe(usb, |
| devpriv->ep_tx->bEndpointAddress), |
| devpriv->usb_tx_buf, |
| request_size, |
| NULL, |
| NI6501_TIMEOUT); |
| if (ret) |
| goto end; |
| |
| ret = usb_bulk_msg(usb, |
| usb_rcvbulkpipe(usb, |
| devpriv->ep_rx->bEndpointAddress), |
| devpriv->usb_rx_buf, |
| response_size, |
| NULL, |
| NI6501_TIMEOUT); |
| if (ret) |
| goto end; |
| |
| /* Check if results are valid */ |
| |
| if (command == READ_PORT) { |
| *bitmap = devpriv->usb_rx_buf[14]; |
| /* mask bitmap for comparing */ |
| devpriv->usb_rx_buf[14] = 0x00; |
| |
| if (memcmp(devpriv->usb_rx_buf, READ_PORT_RESPONSE, |
| sizeof(READ_PORT_RESPONSE))) { |
| ret = -EINVAL; |
| } |
| } else if (memcmp(devpriv->usb_rx_buf, GENERIC_RESPONSE, |
| sizeof(GENERIC_RESPONSE))) { |
| ret = -EINVAL; |
| } |
| end: |
| mutex_unlock(&devpriv->mut); |
| |
| return ret; |
| } |
| |
| static int ni6501_counter_command(struct comedi_device *dev, int command, |
| u32 *val) |
| { |
| struct usb_device *usb = comedi_to_usb_dev(dev); |
| struct ni6501_private *devpriv = dev->private; |
| int request_size, response_size; |
| u8 *tx = devpriv->usb_tx_buf; |
| int ret; |
| |
| if ((command == READ_COUNTER || command == WRITE_COUNTER) && !val) |
| return -EINVAL; |
| |
| mutex_lock(&devpriv->mut); |
| |
| switch (command) { |
| case START_COUNTER: |
| request_size = sizeof(START_COUNTER_REQUEST); |
| response_size = sizeof(GENERIC_RESPONSE); |
| memcpy(tx, START_COUNTER_REQUEST, request_size); |
| break; |
| case STOP_COUNTER: |
| request_size = sizeof(STOP_COUNTER_REQUEST); |
| response_size = sizeof(GENERIC_RESPONSE); |
| memcpy(tx, STOP_COUNTER_REQUEST, request_size); |
| break; |
| case READ_COUNTER: |
| request_size = sizeof(READ_COUNTER_REQUEST); |
| response_size = sizeof(READ_COUNTER_RESPONSE); |
| memcpy(tx, READ_COUNTER_REQUEST, request_size); |
| break; |
| case WRITE_COUNTER: |
| request_size = sizeof(WRITE_COUNTER_REQUEST); |
| response_size = sizeof(GENERIC_RESPONSE); |
| memcpy(tx, WRITE_COUNTER_REQUEST, request_size); |
| /* Setup tx packet: bytes 12,13,14,15 hold the */ |
| /* u32 counter value (Big Endian) */ |
| *((__be32 *)&tx[12]) = cpu_to_be32(*val); |
| break; |
| default: |
| ret = -EINVAL; |
| goto end; |
| } |
| |
| ret = usb_bulk_msg(usb, |
| usb_sndbulkpipe(usb, |
| devpriv->ep_tx->bEndpointAddress), |
| devpriv->usb_tx_buf, |
| request_size, |
| NULL, |
| NI6501_TIMEOUT); |
| if (ret) |
| goto end; |
| |
| ret = usb_bulk_msg(usb, |
| usb_rcvbulkpipe(usb, |
| devpriv->ep_rx->bEndpointAddress), |
| devpriv->usb_rx_buf, |
| response_size, |
| NULL, |
| NI6501_TIMEOUT); |
| if (ret) |
| goto end; |
| |
| /* Check if results are valid */ |
| |
| if (command == READ_COUNTER) { |
| int i; |
| |
| /* Read counter value: bytes 12,13,14,15 of rx packet */ |
| /* hold the u32 counter value (Big Endian) */ |
| *val = be32_to_cpu(*((__be32 *)&devpriv->usb_rx_buf[12])); |
| |
| /* mask counter value for comparing */ |
| for (i = 12; i < sizeof(READ_COUNTER_RESPONSE); ++i) |
| devpriv->usb_rx_buf[i] = 0x00; |
| |
| if (memcmp(devpriv->usb_rx_buf, READ_COUNTER_RESPONSE, |
| sizeof(READ_COUNTER_RESPONSE))) { |
| ret = -EINVAL; |
| } |
| } else if (memcmp(devpriv->usb_rx_buf, GENERIC_RESPONSE, |
| sizeof(GENERIC_RESPONSE))) { |
| ret = -EINVAL; |
| } |
| end: |
| mutex_unlock(&devpriv->mut); |
| |
| return ret; |
| } |
| |
| static int ni6501_dio_insn_config(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, |
| unsigned int *data) |
| { |
| int ret; |
| |
| ret = comedi_dio_insn_config(dev, s, insn, data, 0); |
| if (ret) |
| return ret; |
| |
| ret = ni6501_port_command(dev, SET_PORT_DIR, s->io_bits, NULL); |
| if (ret) |
| return ret; |
| |
| return insn->n; |
| } |
| |
| static int ni6501_dio_insn_bits(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, |
| unsigned int *data) |
| { |
| unsigned int mask; |
| int ret; |
| u8 port; |
| u8 bitmap; |
| |
| mask = comedi_dio_update_state(s, data); |
| |
| for (port = 0; port < 3; port++) { |
| if (mask & (0xFF << port * 8)) { |
| bitmap = (s->state >> port * 8) & 0xFF; |
| ret = ni6501_port_command(dev, WRITE_PORT, |
| port, &bitmap); |
| if (ret) |
| return ret; |
| } |
| } |
| |
| data[1] = 0; |
| |
| for (port = 0; port < 3; port++) { |
| ret = ni6501_port_command(dev, READ_PORT, port, &bitmap); |
| if (ret) |
| return ret; |
| data[1] |= bitmap << port * 8; |
| } |
| |
| return insn->n; |
| } |
| |
| static int ni6501_cnt_insn_config(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, |
| unsigned int *data) |
| { |
| int ret; |
| u32 val = 0; |
| |
| switch (data[0]) { |
| case INSN_CONFIG_ARM: |
| ret = ni6501_counter_command(dev, START_COUNTER, NULL); |
| break; |
| case INSN_CONFIG_DISARM: |
| ret = ni6501_counter_command(dev, STOP_COUNTER, NULL); |
| break; |
| case INSN_CONFIG_RESET: |
| ret = ni6501_counter_command(dev, STOP_COUNTER, NULL); |
| if (ret) |
| break; |
| ret = ni6501_counter_command(dev, WRITE_COUNTER, &val); |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| return ret ? ret : insn->n; |
| } |
| |
| static int ni6501_cnt_insn_read(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, |
| unsigned int *data) |
| { |
| int ret; |
| u32 val; |
| unsigned int i; |
| |
| for (i = 0; i < insn->n; i++) { |
| ret = ni6501_counter_command(dev, READ_COUNTER, &val); |
| if (ret) |
| return ret; |
| data[i] = val; |
| } |
| |
| return insn->n; |
| } |
| |
| static int ni6501_cnt_insn_write(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, |
| unsigned int *data) |
| { |
| int ret; |
| |
| if (insn->n) { |
| u32 val = data[insn->n - 1]; |
| |
| ret = ni6501_counter_command(dev, WRITE_COUNTER, &val); |
| if (ret) |
| return ret; |
| } |
| |
| return insn->n; |
| } |
| |
| static int ni6501_alloc_usb_buffers(struct comedi_device *dev) |
| { |
| struct ni6501_private *devpriv = dev->private; |
| size_t size; |
| |
| size = usb_endpoint_maxp(devpriv->ep_rx); |
| devpriv->usb_rx_buf = kzalloc(size, GFP_KERNEL); |
| if (!devpriv->usb_rx_buf) |
| return -ENOMEM; |
| |
| size = usb_endpoint_maxp(devpriv->ep_tx); |
| devpriv->usb_tx_buf = kzalloc(size, GFP_KERNEL); |
| if (!devpriv->usb_tx_buf) |
| return -ENOMEM; |
| |
| return 0; |
| } |
| |
| static int ni6501_find_endpoints(struct comedi_device *dev) |
| { |
| struct usb_interface *intf = comedi_to_usb_interface(dev); |
| struct ni6501_private *devpriv = dev->private; |
| struct usb_host_interface *iface_desc = intf->cur_altsetting; |
| struct usb_endpoint_descriptor *ep_desc; |
| int i; |
| |
| if (iface_desc->desc.bNumEndpoints != 2) { |
| dev_err(dev->class_dev, "Wrong number of endpoints\n"); |
| return -ENODEV; |
| } |
| |
| for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { |
| ep_desc = &iface_desc->endpoint[i].desc; |
| |
| if (usb_endpoint_is_bulk_in(ep_desc)) { |
| if (!devpriv->ep_rx) |
| devpriv->ep_rx = ep_desc; |
| continue; |
| } |
| |
| if (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; |
| |
| if (usb_endpoint_maxp(devpriv->ep_rx) < RX_MAX_SIZE) |
| return -ENODEV; |
| |
| if (usb_endpoint_maxp(devpriv->ep_tx) < TX_MAX_SIZE) |
| return -ENODEV; |
| |
| return 0; |
| } |
| |
| static int ni6501_auto_attach(struct comedi_device *dev, |
| unsigned long context) |
| { |
| struct usb_interface *intf = comedi_to_usb_interface(dev); |
| struct ni6501_private *devpriv; |
| struct comedi_subdevice *s; |
| int ret; |
| |
| devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv)); |
| if (!devpriv) |
| return -ENOMEM; |
| |
| mutex_init(&devpriv->mut); |
| usb_set_intfdata(intf, devpriv); |
| |
| ret = ni6501_find_endpoints(dev); |
| if (ret) |
| return ret; |
| |
| ret = ni6501_alloc_usb_buffers(dev); |
| if (ret) |
| return ret; |
| |
| ret = comedi_alloc_subdevices(dev, 2); |
| if (ret) |
| return ret; |
| |
| /* Digital Input/Output subdevice */ |
| s = &dev->subdevices[0]; |
| s->type = COMEDI_SUBD_DIO; |
| s->subdev_flags = SDF_READABLE | SDF_WRITABLE; |
| s->n_chan = 24; |
| s->maxdata = 1; |
| s->range_table = &range_digital; |
| s->insn_bits = ni6501_dio_insn_bits; |
| s->insn_config = ni6501_dio_insn_config; |
| |
| /* Counter subdevice */ |
| s = &dev->subdevices[1]; |
| s->type = COMEDI_SUBD_COUNTER; |
| s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_LSAMPL; |
| s->n_chan = 1; |
| s->maxdata = 0xffffffff; |
| s->insn_read = ni6501_cnt_insn_read; |
| s->insn_write = ni6501_cnt_insn_write; |
| s->insn_config = ni6501_cnt_insn_config; |
| |
| return 0; |
| } |
| |
| static void ni6501_detach(struct comedi_device *dev) |
| { |
| struct usb_interface *intf = comedi_to_usb_interface(dev); |
| struct ni6501_private *devpriv = dev->private; |
| |
| if (!devpriv) |
| return; |
| |
| mutex_destroy(&devpriv->mut); |
| |
| usb_set_intfdata(intf, NULL); |
| |
| kfree(devpriv->usb_rx_buf); |
| kfree(devpriv->usb_tx_buf); |
| } |
| |
| static struct comedi_driver ni6501_driver = { |
| .module = THIS_MODULE, |
| .driver_name = "ni6501", |
| .auto_attach = ni6501_auto_attach, |
| .detach = ni6501_detach, |
| }; |
| |
| static int ni6501_usb_probe(struct usb_interface *intf, |
| const struct usb_device_id *id) |
| { |
| return comedi_usb_auto_config(intf, &ni6501_driver, id->driver_info); |
| } |
| |
| static const struct usb_device_id ni6501_usb_table[] = { |
| { USB_DEVICE(0x3923, 0x718a) }, |
| { } |
| }; |
| MODULE_DEVICE_TABLE(usb, ni6501_usb_table); |
| |
| static struct usb_driver ni6501_usb_driver = { |
| .name = "ni6501", |
| .id_table = ni6501_usb_table, |
| .probe = ni6501_usb_probe, |
| .disconnect = comedi_usb_auto_unconfig, |
| }; |
| module_comedi_usb_driver(ni6501_driver, ni6501_usb_driver); |
| |
| MODULE_AUTHOR("Luca Ellero"); |
| MODULE_DESCRIPTION("Comedi driver for National Instruments USB-6501"); |
| MODULE_LICENSE("GPL"); |
