// 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 <linux/comedi/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");