// SPDX-License-Identifier: GPL-2.0

/***************************************************************************
 *     Driver for hp 82341a/b/c/d boards.                                  *
 * Might be worth merging with Agilent 82350b driver.                      *
 *   copyright            : (C) 2002, 2005 by Frank Mori Hess              *
 ***************************************************************************/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#define dev_fmt pr_fmt
#define DRV_NAME KBUILD_MODNAME

#include "hp_82341.h"
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/isapnp.h>

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("GPIB driver for hp 82341a/b/c/d boards");

static unsigned short read_and_clear_event_status(struct gpib_board *board);
static void set_transfer_counter(struct hp_82341_priv *hp_priv, int count);
static int read_transfer_counter(struct hp_82341_priv *hp_priv);
static int hp_82341_write(struct gpib_board *board, u8 *buffer, size_t length, int send_eoi,
                          size_t *bytes_written);
static irqreturn_t hp_82341_interrupt(int irq, void *arg);

static int hp_82341_accel_read(struct gpib_board *board, u8 *buffer, size_t length, int *end,
                               size_t *bytes_read)
{
        struct hp_82341_priv *hp_priv = board->private_data;
        struct tms9914_priv *tms_priv = &hp_priv->tms9914_priv;
        int retval = 0;
        unsigned short event_status;
        int i;
        int num_fifo_bytes;
        // hardware doesn't support checking for end-of-string character when using fifo
        if (tms_priv->eos_flags & REOS)
                return tms9914_read(board, tms_priv, buffer, length, end, bytes_read);

        clear_bit(DEV_CLEAR_BN, &tms_priv->state);

        read_and_clear_event_status(board);
        *end = 0;
        *bytes_read = 0;
        if (length == 0)
                return 0;
        // disable fifo for the moment
        outb(DIRECTION_GPIB_TO_HOST_BIT, hp_priv->iobase[3] + BUFFER_CONTROL_REG);
        /*
         * Handle corner case of board not in holdoff and one byte has slipped in already.
         * Also, board sometimes has problems (spurious 1 byte reads) when read fifo is
         * started up with board in TACS under certain data holdoff conditions.
         * Doing a 1 byte tms9914-style read avoids these problems.
         */
        if (/*tms_priv->holdoff_active == 0 && */length > 1) {
                size_t num_bytes;

                retval = tms9914_read(board, tms_priv, buffer, 1, end, &num_bytes);
                *bytes_read += num_bytes;
                if (retval < 0)
                        dev_err(board->gpib_dev, "tms9914_read failed retval=%i\n", retval);
                if (retval < 0 || *end)
                        return retval;
                ++buffer;
                --length;
        }
        tms9914_set_holdoff_mode(tms_priv, TMS9914_HOLDOFF_EOI);
        tms9914_release_holdoff(tms_priv);
        outb(0x00, hp_priv->iobase[3] + BUFFER_FLUSH_REG);
        i = 0;
        num_fifo_bytes = length - 1;
        while (i < num_fifo_bytes && *end == 0) {
                int block_size;
                int j;
                int count;

                block_size = min(num_fifo_bytes - i, hp_82341_fifo_size);
                set_transfer_counter(hp_priv, block_size);
                outb(ENABLE_TI_BUFFER_BIT | DIRECTION_GPIB_TO_HOST_BIT, hp_priv->iobase[3] +
                     BUFFER_CONTROL_REG);
                if (inb(hp_priv->iobase[0] + STREAM_STATUS_REG) & HALTED_STATUS_BIT)
                        outb(RESTART_STREAM_BIT, hp_priv->iobase[0] + STREAM_STATUS_REG);

                clear_bit(READ_READY_BN, &tms_priv->state);

                retval = wait_event_interruptible(board->wait,
                                                  ((event_status =
                                                    read_and_clear_event_status(board)) &
                                                   (TERMINAL_COUNT_EVENT_BIT |
                                                    BUFFER_END_EVENT_BIT)) ||
                                                  test_bit(DEV_CLEAR_BN, &tms_priv->state) ||
                                                  test_bit(TIMO_NUM, &board->status));
                if (retval)  {
                        retval = -ERESTARTSYS;
                        break;
                }
                // have to disable buffer before we can read from buffer port
                outb(DIRECTION_GPIB_TO_HOST_BIT, hp_priv->iobase[3] + BUFFER_CONTROL_REG);
                count = block_size - read_transfer_counter(hp_priv);
                j = 0;
                while (j < count && i < num_fifo_bytes) {
                        unsigned short data_word = inw(hp_priv->iobase[3] + BUFFER_PORT_LOW_REG);

                        buffer[i++] = data_word & 0xff;
                        ++j;
                        if (j < count && i < num_fifo_bytes) {
                                buffer[i++] = (data_word >> 8) & 0xff;
                                ++j;
                        }
                }
                if (event_status & BUFFER_END_EVENT_BIT) {
                        clear_bit(RECEIVED_END_BN, &tms_priv->state);

                        *end = 1;
                        tms_priv->holdoff_active = 1;
                }
                if (test_bit(TIMO_NUM, &board->status)) {
                        retval = -ETIMEDOUT;
                        break;
                }
                if (test_bit(DEV_CLEAR_BN, &tms_priv->state)) {
                        retval = -EINTR;
                        break;
                }
        }
        *bytes_read += i;
        buffer += i;
        length -= i;
        if (retval < 0)
                return retval;
        // read last byte if we havn't received an END yet
        if (*end == 0) {
                size_t num_bytes;
                // try to make sure we holdoff after last byte read
                retval = tms9914_read(board, tms_priv, buffer, length, end, &num_bytes);
                *bytes_read += num_bytes;
                if (retval < 0)
                        return retval;
        }
        return 0;
}

static int restart_write_fifo(struct gpib_board *board, struct hp_82341_priv *hp_priv)
{
        struct tms9914_priv *tms_priv = &hp_priv->tms9914_priv;

        if ((inb(hp_priv->iobase[0] + STREAM_STATUS_REG) & HALTED_STATUS_BIT) == 0)
                return 0;
        while (1) {
                int status;

                // restart doesn't work if data holdoff is in effect
                status = tms9914_line_status(board, tms_priv);
                if ((status & BUS_NRFD) == 0) {
                        outb(RESTART_STREAM_BIT, hp_priv->iobase[0] + STREAM_STATUS_REG);
                        return 0;
                }
                if (test_bit(DEV_CLEAR_BN, &tms_priv->state))
                        return -EINTR;
                if (test_bit(TIMO_NUM, &board->status))
                        return -ETIMEDOUT;
                if (msleep_interruptible(1))
                        return -EINTR;
        }
        return 0;
}

static int hp_82341_accel_write(struct gpib_board *board, u8 *buffer, size_t length,
                                int send_eoi, size_t *bytes_written)
{
        struct hp_82341_priv *hp_priv = board->private_data;
        struct tms9914_priv *tms_priv = &hp_priv->tms9914_priv;
        int i, j;
        unsigned short event_status;
        int retval = 0;
        int fifo_xfer_len = length;

        *bytes_written = 0;
        if (send_eoi)
                --fifo_xfer_len;

        clear_bit(DEV_CLEAR_BN, &tms_priv->state);

        read_and_clear_event_status(board);
        outb(0, hp_priv->iobase[3] + BUFFER_CONTROL_REG);
        outb(0x00, hp_priv->iobase[3] + BUFFER_FLUSH_REG);
        for (i = 0; i < fifo_xfer_len;) {
                int block_size;

                block_size = min(fifo_xfer_len - i, hp_82341_fifo_size);
                set_transfer_counter(hp_priv, block_size);
                // load data into board's fifo
                for (j = 0; j < block_size;) {
                        unsigned short data_word = buffer[i++];
                        ++j;
                        if (j < block_size) {
                                data_word |= buffer[i++] << 8;
                                ++j;
                        }
                        outw(data_word, hp_priv->iobase[3] + BUFFER_PORT_LOW_REG);
                }
                clear_bit(WRITE_READY_BN, &tms_priv->state);
                outb(ENABLE_TI_BUFFER_BIT, hp_priv->iobase[3] + BUFFER_CONTROL_REG);
                retval = restart_write_fifo(board, hp_priv);
                if (retval < 0) {
                        dev_err(board->gpib_dev, "failed to restart write stream\n");
                        break;
                }
                retval = wait_event_interruptible(board->wait,
                                                  ((event_status =
                                                    read_and_clear_event_status(board)) &
                                                   TERMINAL_COUNT_EVENT_BIT) ||
                                                  test_bit(DEV_CLEAR_BN, &tms_priv->state) ||
                                                  test_bit(TIMO_NUM, &board->status));
                outb(0, hp_priv->iobase[3] + BUFFER_CONTROL_REG);
                *bytes_written += block_size - read_transfer_counter(hp_priv);
                if (retval) {
                        retval = -ERESTARTSYS;
                        break;
                }
                if (test_bit(TIMO_NUM, &board->status)) {
                        retval = -ETIMEDOUT;
                        break;
                }
                if (test_bit(DEV_CLEAR_BN, &tms_priv->state)) {
                        retval = -EINTR;
                        break;
                }
        }
        if (retval)
                return retval;
        if (send_eoi) {
                size_t num_bytes;

                retval = hp_82341_write(board, buffer + fifo_xfer_len, 1, 1, &num_bytes);
                *bytes_written += num_bytes;
                if (retval < 0)
                        return retval;
        }
        return 0;
}

static int hp_82341_attach(struct gpib_board *board, const struct gpib_board_config *config);

static void hp_82341_detach(struct gpib_board *board);

// wrappers for interface functions
static int hp_82341_read(struct gpib_board *board, u8 *buffer, size_t length, int *end,
                         size_t *bytes_read)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_read(board, &priv->tms9914_priv, buffer, length, end, bytes_read);
}

static int hp_82341_write(struct gpib_board *board, u8 *buffer, size_t length, int send_eoi,
                          size_t *bytes_written)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_write(board, &priv->tms9914_priv, buffer, length, send_eoi, bytes_written);
}

static int hp_82341_command(struct gpib_board *board, u8 *buffer, size_t length,
                            size_t *bytes_written)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_command(board, &priv->tms9914_priv, buffer, length, bytes_written);
}

static int hp_82341_take_control(struct gpib_board *board, int synchronous)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_take_control(board, &priv->tms9914_priv, synchronous);
}

static int hp_82341_go_to_standby(struct gpib_board *board)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_go_to_standby(board, &priv->tms9914_priv);
}

static int hp_82341_request_system_control(struct gpib_board *board, int request_control)
{
        struct hp_82341_priv *priv = board->private_data;

        if (request_control)
                priv->mode_control_bits |= SYSTEM_CONTROLLER_BIT;
        else
                priv->mode_control_bits &= ~SYSTEM_CONTROLLER_BIT;
        outb(priv->mode_control_bits, priv->iobase[0] + MODE_CONTROL_STATUS_REG);
        return tms9914_request_system_control(board, &priv->tms9914_priv, request_control);
}

static void hp_82341_interface_clear(struct gpib_board *board, int assert)
{
        struct hp_82341_priv *priv = board->private_data;

        tms9914_interface_clear(board, &priv->tms9914_priv, assert);
}

static void hp_82341_remote_enable(struct gpib_board *board, int enable)
{
        struct hp_82341_priv *priv = board->private_data;

        tms9914_remote_enable(board, &priv->tms9914_priv, enable);
}

static int hp_82341_enable_eos(struct gpib_board *board, u8 eos_byte, int compare_8_bits)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_enable_eos(board, &priv->tms9914_priv, eos_byte, compare_8_bits);
}

static void hp_82341_disable_eos(struct gpib_board *board)
{
        struct hp_82341_priv *priv = board->private_data;

        tms9914_disable_eos(board, &priv->tms9914_priv);
}

static unsigned int hp_82341_update_status(struct gpib_board *board, unsigned int clear_mask)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_update_status(board, &priv->tms9914_priv, clear_mask);
}

static int hp_82341_primary_address(struct gpib_board *board, unsigned int address)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_primary_address(board, &priv->tms9914_priv, address);
}

static int hp_82341_secondary_address(struct gpib_board *board, unsigned int address, int enable)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_secondary_address(board, &priv->tms9914_priv, address, enable);
}

static int hp_82341_parallel_poll(struct gpib_board *board, u8 *result)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_parallel_poll(board, &priv->tms9914_priv, result);
}

static void hp_82341_parallel_poll_configure(struct gpib_board *board, u8 config)
{
        struct hp_82341_priv *priv = board->private_data;

        tms9914_parallel_poll_configure(board, &priv->tms9914_priv, config);
}

static void hp_82341_parallel_poll_response(struct gpib_board *board, int ist)
{
        struct hp_82341_priv *priv = board->private_data;

        tms9914_parallel_poll_response(board, &priv->tms9914_priv, ist);
}

static void hp_82341_serial_poll_response(struct gpib_board *board, u8 status)
{
        struct hp_82341_priv *priv = board->private_data;

        tms9914_serial_poll_response(board, &priv->tms9914_priv, status);
}

static u8 hp_82341_serial_poll_status(struct gpib_board *board)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_serial_poll_status(board, &priv->tms9914_priv);
}

static int hp_82341_line_status(const struct gpib_board *board)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_line_status(board, &priv->tms9914_priv);
}

static int hp_82341_t1_delay(struct gpib_board *board, unsigned int nano_sec)
{
        struct hp_82341_priv *priv = board->private_data;

        return tms9914_t1_delay(board, &priv->tms9914_priv, nano_sec);
}

static void hp_82341_return_to_local(struct gpib_board *board)
{
        struct hp_82341_priv *priv = board->private_data;

        tms9914_return_to_local(board, &priv->tms9914_priv);
}

static struct gpib_interface hp_82341_unaccel_interface = {
        .name = "hp_82341_unaccel",
        .attach = hp_82341_attach,
        .detach = hp_82341_detach,
        .read = hp_82341_read,
        .write = hp_82341_write,
        .command = hp_82341_command,
        .request_system_control = hp_82341_request_system_control,
        .take_control = hp_82341_take_control,
        .go_to_standby = hp_82341_go_to_standby,
        .interface_clear = hp_82341_interface_clear,
        .remote_enable = hp_82341_remote_enable,
        .enable_eos = hp_82341_enable_eos,
        .disable_eos = hp_82341_disable_eos,
        .parallel_poll = hp_82341_parallel_poll,
        .parallel_poll_configure = hp_82341_parallel_poll_configure,
        .parallel_poll_response = hp_82341_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = hp_82341_line_status,
        .update_status = hp_82341_update_status,
        .primary_address = hp_82341_primary_address,
        .secondary_address = hp_82341_secondary_address,
        .serial_poll_response = hp_82341_serial_poll_response,
        .serial_poll_status = hp_82341_serial_poll_status,
        .t1_delay = hp_82341_t1_delay,
        .return_to_local = hp_82341_return_to_local,
};

static struct gpib_interface hp_82341_interface = {
        .name = "hp_82341",
        .attach = hp_82341_attach,
        .detach = hp_82341_detach,
        .read = hp_82341_accel_read,
        .write = hp_82341_accel_write,
        .command = hp_82341_command,
        .request_system_control = hp_82341_request_system_control,
        .take_control = hp_82341_take_control,
        .go_to_standby = hp_82341_go_to_standby,
        .interface_clear = hp_82341_interface_clear,
        .remote_enable = hp_82341_remote_enable,
        .enable_eos = hp_82341_enable_eos,
        .disable_eos = hp_82341_disable_eos,
        .parallel_poll = hp_82341_parallel_poll,
        .parallel_poll_configure = hp_82341_parallel_poll_configure,
        .parallel_poll_response = hp_82341_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = hp_82341_line_status,
        .update_status = hp_82341_update_status,
        .primary_address = hp_82341_primary_address,
        .secondary_address = hp_82341_secondary_address,
        .serial_poll_response = hp_82341_serial_poll_response,
        .t1_delay = hp_82341_t1_delay,
        .return_to_local = hp_82341_return_to_local,
};

static int hp_82341_allocate_private(struct gpib_board *board)
{
        board->private_data = kzalloc_obj(struct hp_82341_priv);
        if (!board->private_data)
                return -ENOMEM;
        return 0;
}

static void hp_82341_free_private(struct gpib_board *board)
{
        kfree(board->private_data);
        board->private_data = NULL;
}

static u8 hp_82341_read_byte(struct tms9914_priv *priv, unsigned int register_num)
{
        return inb(priv->iobase + register_num);
}

static void hp_82341_write_byte(struct tms9914_priv *priv, u8 data, unsigned int register_num)
{
        outb(data, priv->iobase + register_num);
}

static int hp_82341_find_isapnp_board(struct pnp_dev **dev)
{
        *dev = pnp_find_dev(NULL, ISAPNP_VENDOR('H', 'W', 'P'),
                            ISAPNP_FUNCTION(0x1411), NULL);
        if (!*dev || !(*dev)->card) {
                pr_err("failed to find isapnp board\n");
                return -ENODEV;
        }
        if (pnp_device_attach(*dev) < 0) {
                pr_err("board already active, skipping\n");
                return -EBUSY;
        }
        if (pnp_activate_dev(*dev) < 0) {
                pnp_device_detach(*dev);
                pr_err("failed to activate(), aborting\n");
                return -EAGAIN;
        }
        if (!pnp_port_valid(*dev, 0) || !pnp_irq_valid(*dev, 0)) {
                pnp_device_detach(*dev);
                pr_err("invalid port or irq, aborting\n");
                return -ENOMEM;
        }
        return 0;
}

static int xilinx_ready(struct hp_82341_priv *hp_priv)
{
        switch (hp_priv->hw_version) {
        case HW_VERSION_82341C:
                if (inb(hp_priv->iobase[0] + CONFIG_CONTROL_STATUS_REG) & XILINX_READY_BIT)
                        return 1;
                else
                        return 0;
                break;
        case HW_VERSION_82341D:
                if (isapnp_read_byte(PIO_DATA_REG) & HP_82341D_XILINX_READY_BIT)
                        return 1;
                else
                        return 0;
        default:
                pr_err("bug! unknown hw_version\n");
                break;
        }
        return 0;
}

static int xilinx_done(struct hp_82341_priv *hp_priv)
{
        switch (hp_priv->hw_version) {
        case HW_VERSION_82341C:
                if (inb(hp_priv->iobase[0] + CONFIG_CONTROL_STATUS_REG) & DONE_PGL_BIT)
                        return 1;
                else
                        return 0;
        case HW_VERSION_82341D:
                if (isapnp_read_byte(PIO_DATA_REG) & HP_82341D_XILINX_DONE_BIT)
                        return 1;
                else
                        return 0;
        default:
                pr_err("bug! unknown hw_version\n");
                break;
        }
        return 0;
}

static int irq_valid(struct hp_82341_priv *hp_priv, int irq)
{
        switch (hp_priv->hw_version) {
        case HW_VERSION_82341C:
                switch (irq) {
                case 3:
                case 5:
                case 7:
                case 9:
                case 10:
                case 11:
                case 12:
                case 15:
                        return 1;
                default:
                        pr_err("invalid irq=%i for 82341C, irq must be 3, 5, 7, 9, 10, 11, 12, or 15.\n",
                               irq);
                        return 0;
                }
                break;
        case HW_VERSION_82341D:
                return 1;
        default:
                pr_err("bug! unknown hw_version\n");
                break;
        }
        return 0;
}

static int hp_82341_load_firmware_array(struct hp_82341_priv *hp_priv,
                                        const unsigned char *firmware_data,
                                        unsigned int firmware_length)
{
        int i, j;
        static const int timeout = 100;

        for (i = 0; i < firmware_length; ++i) {
                for (j = 0; j < timeout; ++j) {
                        if (need_resched())
                                schedule();
                        if (xilinx_ready(hp_priv))
                                break;
                        usleep_range(10, 15);
                }
                if (j == timeout) {
                        pr_err("timed out waiting for Xilinx ready.\n");
                        return -ETIMEDOUT;
                }
                outb(firmware_data[i], hp_priv->iobase[0] + XILINX_DATA_REG);
        }
        for (j = 0; j < timeout; ++j) {
                if (xilinx_done(hp_priv))
                        break;
                if (need_resched())
                        schedule();
                usleep_range(10, 15);
        }
        if (j == timeout) {
                pr_err("timed out waiting for Xilinx done.\n");
                return -ETIMEDOUT;
        }
        return 0;
}

static int hp_82341_load_firmware(struct hp_82341_priv *hp_priv,
                                  const struct gpib_board_config *config)
{
        if (config->init_data_length == 0) {
                if (xilinx_done(hp_priv))
                        return 0;
                pr_err("board needs be initialized with firmware upload.\n"
                       "\tUse the --init-data option of gpib_config.\n");
                return -EINVAL;
        }
        switch (hp_priv->hw_version) {
        case HW_VERSION_82341C:
                if (config->init_data_length != hp_82341c_firmware_length) {
                        pr_err("bad firmware length=%i for 82341c (expected %i).\n",
                               config->init_data_length, hp_82341c_firmware_length);
                        return -EINVAL;
                }
                break;
        case HW_VERSION_82341D:
                if (config->init_data_length != hp_82341d_firmware_length) {
                        pr_err("bad firmware length=%i for 82341d (expected %i).\n",
                               config->init_data_length, hp_82341d_firmware_length);
                        return -EINVAL;
                }
                break;
        default:
                pr_err("bug! unknown hw_version\n");
                break;
        }
        return hp_82341_load_firmware_array(hp_priv, config->init_data, config->init_data_length);
}

static void set_xilinx_not_prog(struct hp_82341_priv *hp_priv, int assert)
{
        switch (hp_priv->hw_version) {
        case HW_VERSION_82341C:
                if (assert)
                        hp_priv->config_control_bits |= DONE_PGL_BIT;
                else
                        hp_priv->config_control_bits &= ~DONE_PGL_BIT;
                outb(hp_priv->config_control_bits, hp_priv->iobase[0] + CONFIG_CONTROL_STATUS_REG);
                break;
        case HW_VERSION_82341D:
                if (assert)
                        isapnp_write_byte(PIO_DATA_REG, HP_82341D_NOT_PROG_BIT);
                else
                        isapnp_write_byte(PIO_DATA_REG, 0x0);
                break;
        default:
                break;
        }
}

// clear xilinx firmware
static int clear_xilinx(struct hp_82341_priv *hp_priv)
{
        set_xilinx_not_prog(hp_priv, 1);
        if (msleep_interruptible(1))
                return -EINTR;
        set_xilinx_not_prog(hp_priv, 0);
        if (msleep_interruptible(1))
                return -EINTR;
        set_xilinx_not_prog(hp_priv, 1);
        if (msleep_interruptible(1))
                return -EINTR;
        return 0;
}

static int hp_82341_attach(struct gpib_board *board, const struct gpib_board_config *config)
{
        struct hp_82341_priv *hp_priv;
        struct tms9914_priv *tms_priv;
        u32 start_addr;
        u32 iobase;
        int irq;
        int i;
        int retval;

        board->status = 0;
        retval = hp_82341_allocate_private(board);
        if (retval)
                return retval;
        hp_priv = board->private_data;
        tms_priv = &hp_priv->tms9914_priv;
        tms_priv->read_byte = hp_82341_read_byte;
        tms_priv->write_byte = hp_82341_write_byte;
        tms_priv->offset = 1;

        if (config->ibbase == 0) {
                struct pnp_dev *dev;
                int retval = hp_82341_find_isapnp_board(&dev);

                if (retval < 0)
                        return retval;
                hp_priv->pnp_dev = dev;
                iobase = pnp_port_start(dev, 0);
                irq = pnp_irq(dev, 0);
                hp_priv->hw_version = HW_VERSION_82341D;
                hp_priv->io_region_offset = 0x8;
        } else {
                iobase = config->ibbase;
                irq = config->ibirq;
                hp_priv->hw_version = HW_VERSION_82341C;
                hp_priv->io_region_offset = 0x400;
        }
        for (i = 0; i < hp_82341_num_io_regions; ++i) {
                start_addr = iobase + i * hp_priv->io_region_offset;
                if (!request_region(start_addr, hp_82341_region_iosize, DRV_NAME)) {
                        dev_err(board->gpib_dev, "failed to allocate io ports 0x%x-0x%x\n",
                                start_addr,
                                start_addr + hp_82341_region_iosize - 1);
                        return -EIO;
                }
                hp_priv->iobase[i] = start_addr;
        }
        tms_priv->iobase = hp_priv->iobase[2];
        if (hp_priv->hw_version == HW_VERSION_82341D) {
                retval = isapnp_cfg_begin(hp_priv->pnp_dev->card->number,
                                          hp_priv->pnp_dev->number);
                if (retval < 0) {
                        dev_err(board->gpib_dev, "isapnp_cfg_begin returned error\n");
                        return retval;
                }
                isapnp_write_byte(PIO_DIRECTION_REG, HP_82341D_XILINX_READY_BIT |
                                  HP_82341D_XILINX_DONE_BIT);
        }
        retval = clear_xilinx(hp_priv);
        if (retval < 0)
                return retval;
        retval = hp_82341_load_firmware(hp_priv, config);
        if (hp_priv->hw_version == HW_VERSION_82341D)
                isapnp_cfg_end();
        if (retval < 0)
                return retval;
        if (irq_valid(hp_priv, irq) == 0)
                return -EINVAL;
        if (request_irq(irq, hp_82341_interrupt, 0, DRV_NAME, board))   {
                dev_err(board->gpib_dev, "failed to allocate IRQ %d\n", irq);
                return -EIO;
        }
        hp_priv->irq = irq;
        hp_priv->config_control_bits &= ~IRQ_SELECT_MASK;
        hp_priv->config_control_bits |= IRQ_SELECT_BITS(irq);
        outb(hp_priv->config_control_bits, hp_priv->iobase[0] + CONFIG_CONTROL_STATUS_REG);
        hp_priv->mode_control_bits |= ENABLE_IRQ_CONFIG_BIT;
        outb(hp_priv->mode_control_bits, hp_priv->iobase[0] + MODE_CONTROL_STATUS_REG);
        tms9914_board_reset(tms_priv);
        outb(ENABLE_BUFFER_END_EVENT_BIT | ENABLE_TERMINAL_COUNT_EVENT_BIT |
             ENABLE_TI_INTERRUPT_EVENT_BIT, hp_priv->iobase[0] +  EVENT_ENABLE_REG);
        outb(ENABLE_BUFFER_END_INTERRUPT_BIT | ENABLE_TERMINAL_COUNT_INTERRUPT_BIT |
             ENABLE_TI_INTERRUPT_BIT, hp_priv->iobase[0] + INTERRUPT_ENABLE_REG);
        // write clear event register
        outb((TI_INTERRUPT_EVENT_BIT | POINTERS_EQUAL_EVENT_BIT |
              BUFFER_END_EVENT_BIT | TERMINAL_COUNT_EVENT_BIT),
             hp_priv->iobase[0] + EVENT_STATUS_REG);

        tms9914_online(board, tms_priv);

        return 0;
}

static void hp_82341_detach(struct gpib_board *board)
{
        struct hp_82341_priv *hp_priv = board->private_data;
        struct tms9914_priv *tms_priv;
        int i;

        if (hp_priv) {
                tms_priv = &hp_priv->tms9914_priv;
                if (hp_priv->iobase[0]) {
                        outb(0, hp_priv->iobase[0] + INTERRUPT_ENABLE_REG);
                        if (tms_priv->iobase)
                                tms9914_board_reset(tms_priv);
                        if (hp_priv->irq)
                                free_irq(hp_priv->irq, board);
                }
                for (i = 0; i < hp_82341_num_io_regions; ++i) {
                        if (hp_priv->iobase[i])
                                release_region(hp_priv->iobase[i], hp_82341_region_iosize);
                }
                if (hp_priv->pnp_dev)
                        pnp_device_detach(hp_priv->pnp_dev);
        }
        hp_82341_free_private(board);
}

#if 0
/* unused, will be needed when the driver is turned into a pnp_driver */
static const struct pnp_device_id hp_82341_pnp_table[] = {
        {.id = "HWP1411"},
        {.id = ""}
};
MODULE_DEVICE_TABLE(pnp, hp_82341_pnp_table);
#endif

static int __init hp_82341_init_module(void)
{
        int ret;

        ret = gpib_register_driver(&hp_82341_unaccel_interface, THIS_MODULE);
        if (ret) {
                pr_err("gpib_register_driver failed: error = %d\n", ret);
                return ret;
        }

        ret = gpib_register_driver(&hp_82341_interface, THIS_MODULE);
        if (ret) {
                pr_err("gpib_register_driver failed: error = %d\n", ret);
                gpib_unregister_driver(&hp_82341_unaccel_interface);
                return ret;
        }

        return 0;
}

static void __exit hp_82341_exit_module(void)
{
        gpib_unregister_driver(&hp_82341_interface);
        gpib_unregister_driver(&hp_82341_unaccel_interface);
}

module_init(hp_82341_init_module);
module_exit(hp_82341_exit_module);

/*
 * GPIB interrupt service routines
 */
static unsigned short read_and_clear_event_status(struct gpib_board *board)
{
        struct hp_82341_priv *hp_priv = board->private_data;
        unsigned long flags;
        unsigned short status;

        spin_lock_irqsave(&board->spinlock, flags);
        status = hp_priv->event_status_bits;
        hp_priv->event_status_bits = 0;
        spin_unlock_irqrestore(&board->spinlock, flags);
        return status;
}

static irqreturn_t hp_82341_interrupt(int irq, void *arg)
{
        int status1, status2;
        struct gpib_board *board = arg;
        struct hp_82341_priv *hp_priv = board->private_data;
        struct tms9914_priv *tms_priv = &hp_priv->tms9914_priv;
        unsigned long flags;
        irqreturn_t retval = IRQ_NONE;
        int event_status;

        spin_lock_irqsave(&board->spinlock, flags);
        event_status = inb(hp_priv->iobase[0] + EVENT_STATUS_REG);
        if (event_status & INTERRUPT_PENDING_EVENT_BIT)
                retval = IRQ_HANDLED;
        // write-clear status bits
        if (event_status & (TI_INTERRUPT_EVENT_BIT | POINTERS_EQUAL_EVENT_BIT |
                            BUFFER_END_EVENT_BIT | TERMINAL_COUNT_EVENT_BIT)) {
                outb(event_status & (TI_INTERRUPT_EVENT_BIT | POINTERS_EQUAL_EVENT_BIT |
                                     BUFFER_END_EVENT_BIT | TERMINAL_COUNT_EVENT_BIT),
                     hp_priv->iobase[0] + EVENT_STATUS_REG);
                hp_priv->event_status_bits |= event_status;
        }
        if (event_status & TI_INTERRUPT_EVENT_BIT) {
                status1 = read_byte(tms_priv, ISR0);
                status2 = read_byte(tms_priv, ISR1);
                tms9914_interrupt_have_status(board, tms_priv, status1, status2);
        }
        spin_unlock_irqrestore(&board->spinlock, flags);
        return retval;
}

static int read_transfer_counter(struct hp_82341_priv *hp_priv)
{
        int lo, mid, value;

        lo = inb(hp_priv->iobase[1] + TRANSFER_COUNT_LOW_REG);
        mid = inb(hp_priv->iobase[1] + TRANSFER_COUNT_MID_REG);
        value = (lo & 0xff) | ((mid << 8) & 0x7f00);
        value = ~(value - 1) & 0x7fff;
        return value;
}

static void set_transfer_counter(struct hp_82341_priv *hp_priv, int count)
{
        int complement = -count;

        outb(complement & 0xff, hp_priv->iobase[1] + TRANSFER_COUNT_LOW_REG);
        outb((complement >> 8) & 0xff, hp_priv->iobase[1] + TRANSFER_COUNT_MID_REG);
        // I don't think the hi count reg is even used, but oh well
        outb((complement >> 16) & 0xf, hp_priv->iobase[1] + TRANSFER_COUNT_HIGH_REG);
}