// SPDX-License-Identifier: GPL-2.0

/***************************************************************************
 *    copyright            : (C) 1999 Axel Dziemba (axel.dziemba@ines.de)
 *                          (C) 2002 by Frank Mori Hess
 ***************************************************************************/

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

#include "ines.h"

#include <linux/pci.h>
#include <linux/pci_ids.h>
#include <linux/bitops.h>
#include <asm/dma.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include "gpib_pci_ids.h"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("GPIB driver for Ines iGPIB 72010");

static irqreturn_t ines_interrupt(struct gpib_board *board);

static int ines_line_status(const struct gpib_board *board)
{
        int status = VALID_ALL;
        int bcm_bits;
        struct ines_priv *ines_priv;

        ines_priv = board->private_data;

        bcm_bits = ines_inb(ines_priv, BUS_CONTROL_MONITOR);

        if (bcm_bits & BCM_REN_BIT)
                status |= BUS_REN;
        if (bcm_bits & BCM_IFC_BIT)
                status |= BUS_IFC;
        if (bcm_bits & BCM_SRQ_BIT)
                status |= BUS_SRQ;
        if (bcm_bits & BCM_EOI_BIT)
                status |= BUS_EOI;
        if (bcm_bits & BCM_NRFD_BIT)
                status |= BUS_NRFD;
        if (bcm_bits & BCM_NDAC_BIT)
                status |= BUS_NDAC;
        if (bcm_bits & BCM_DAV_BIT)
                status |= BUS_DAV;
        if (bcm_bits & BCM_ATN_BIT)
                status |= BUS_ATN;

        return status;
}

static int ines72130_line_status(const struct gpib_board *board)
{
        int status = VALID_ALL;
        int bsr_bits;
        struct ines_priv *ines_priv = board->private_data;

        bsr_bits = ines_inb(ines_priv, BUS_STATUS_REG);

        if (bsr_bits & BSR_REN_BIT)
                status |= BUS_REN;
        if (bsr_bits & BSR_IFC_BIT)
                status |= BUS_IFC;
        if (bsr_bits & BSR_SRQ_BIT)
                status |= BUS_SRQ;
        if (bsr_bits & BSR_EOI_BIT)
                status |= BUS_EOI;
        if (bsr_bits & BSR_NRFD_BIT)
                status |= BUS_NRFD;
        if (bsr_bits & BSR_NDAC_BIT)
                status |= BUS_NDAC;
        if (bsr_bits & BSR_DAV_BIT)
                status |= BUS_DAV;
        if (bsr_bits & BSR_ATN_BIT)
                status |= BUS_ATN;

        return status;
}

static void ines_set_xfer_counter(struct ines_priv *priv, unsigned int count)
{
        if (count > 0xffff) {
                pr_err("bug! tried to set xfer counter > 0xffff\n");
                return;
        }
        ines_outb(priv, (count >> 8) & 0xff, XFER_COUNT_UPPER);
        ines_outb(priv, count & 0xff, XFER_COUNT_LOWER);
}

static int ines_t1_delay(struct gpib_board *board, unsigned int nano_sec)
{
        struct ines_priv *ines_priv = board->private_data;
        struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
        unsigned int retval;

        retval = nec7210_t1_delay(board, nec_priv, nano_sec);

        if (ines_priv->pci_chip_type == PCI_CHIP_INES_72130)
                return retval;

        if (nano_sec <= 250) {
                write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_250ns |
                           INES_INITIAL_T1_2000ns, AUXMR);
                retval = 250;
        } else if (nano_sec <= 350) {
                write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_350ns |
                           INES_INITIAL_T1_2000ns, AUXMR);
                retval = 350;
        } else {
                write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_500ns |
                           INES_INITIAL_T1_2000ns, AUXMR);
                retval = 500;
        }

        return retval;
}

static inline unsigned short num_in_fifo_bytes(struct ines_priv *ines_priv)
{
        return ines_inb(ines_priv, IN_FIFO_COUNT);
}

static ssize_t pio_read(struct gpib_board *board, struct ines_priv *ines_priv, u8 *buffer,
                        size_t length, size_t *nbytes)
{
        ssize_t retval = 0;
        unsigned int num_fifo_bytes, i;
        struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;

        *nbytes = 0;
        while (*nbytes < length) {
                if (wait_event_interruptible(board->wait,
                                             num_in_fifo_bytes(ines_priv) ||
                                             test_bit(RECEIVED_END_BN, &nec_priv->state) ||
                                             test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
                                             test_bit(TIMO_NUM, &board->status)))
                        return -ERESTARTSYS;

                if (test_bit(TIMO_NUM, &board->status))
                        return -ETIMEDOUT;
                if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
                        return -EINTR;

                num_fifo_bytes = num_in_fifo_bytes(ines_priv);
                if (num_fifo_bytes + *nbytes > length)
                        num_fifo_bytes = length - *nbytes;

                for (i = 0; i < num_fifo_bytes; i++)
                        buffer[(*nbytes)++] = read_byte(nec_priv, DIR);
                if (test_bit(RECEIVED_END_BN, &nec_priv->state) &&
                    num_in_fifo_bytes(ines_priv) == 0)
                        break;
                if (need_resched())
                        schedule();
        }
        /* make sure RECEIVED_END is in sync */
        ines_interrupt(board);
        return retval;
}

static int ines_accel_read(struct gpib_board *board, u8 *buffer,
                           size_t length, int *end, size_t *bytes_read)
{
        ssize_t retval = 0;
        struct ines_priv *ines_priv = board->private_data;
        struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
        int counter_setting;

        *end = 0;
        *bytes_read = 0;
        if (length == 0)
                return 0;

        clear_bit(DEV_CLEAR_BN, &nec_priv->state);

        write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);

        // clear in fifo
        nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT, 0);
        nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT, IN_FIFO_ENABLE_BIT);

        ines_priv->extend_mode_bits |= LAST_BYTE_HANDLING_BIT;
        ines_priv->extend_mode_bits &= ~XFER_COUNTER_OUTPUT_BIT & ~XFER_COUNTER_ENABLE_BIT;
        ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);

        counter_setting = length - num_in_fifo_bytes(ines_priv);
        if (counter_setting > 0) {
                ines_set_xfer_counter(ines_priv, length);
                ines_priv->extend_mode_bits |= XFER_COUNTER_ENABLE_BIT;
                ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);

                // holdoff on END
                nec7210_set_handshake_mode(board, nec_priv, HR_HLDE);
                /* release rfd holdoff */
                write_byte(nec_priv, AUX_FH, AUXMR);
        }

        retval = pio_read(board, ines_priv, buffer, length, bytes_read);
        ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
        ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
        if (retval < 0) {
                write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
                return retval;
        }
        if (test_and_clear_bit(RECEIVED_END_BN, &nec_priv->state))
                *end = 1;

        return retval;
}

static const int out_fifo_size = 0xff;

static inline unsigned short num_out_fifo_bytes(struct ines_priv *ines_priv)
{
        return ines_inb(ines_priv, OUT_FIFO_COUNT);
}

static int ines_write_wait(struct gpib_board *board, struct ines_priv *ines_priv,
                           unsigned int fifo_threshold)
{
        struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;

        // wait until byte is ready to be sent
        if (wait_event_interruptible(board->wait,
                                     num_out_fifo_bytes(ines_priv) < fifo_threshold ||
                                     test_bit(BUS_ERROR_BN, &nec_priv->state) ||
                                     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
                                     test_bit(TIMO_NUM, &board->status)))
                return -ERESTARTSYS;

        if (test_bit(BUS_ERROR_BN, &nec_priv->state))
                return -EIO;
        if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
                return -EINTR;
        if (test_bit(TIMO_NUM, &board->status))
                return -ETIMEDOUT;

        return 0;
}

static int ines_accel_write(struct gpib_board *board, u8 *buffer, size_t length,
                            int send_eoi, size_t *bytes_written)
{
        size_t count = 0;
        ssize_t retval = 0;
        struct ines_priv *ines_priv = board->private_data;
        struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
        unsigned int num_bytes, i;

        *bytes_written = 0;
        // clear out fifo
        nec7210_set_reg_bits(nec_priv, ADMR, OUT_FIFO_ENABLE_BIT, 0);
        nec7210_set_reg_bits(nec_priv, ADMR, OUT_FIFO_ENABLE_BIT, OUT_FIFO_ENABLE_BIT);

        ines_priv->extend_mode_bits |= XFER_COUNTER_OUTPUT_BIT;
        ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
        ines_priv->extend_mode_bits &= ~LAST_BYTE_HANDLING_BIT;
        ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);

        ines_set_xfer_counter(ines_priv, length);
        if (send_eoi)
                ines_priv->extend_mode_bits |= LAST_BYTE_HANDLING_BIT;
        ines_priv->extend_mode_bits |= XFER_COUNTER_ENABLE_BIT;
        ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);

        while (count < length) {
                retval = ines_write_wait(board, ines_priv, out_fifo_size);
                if (retval < 0)
                        break;

                num_bytes = out_fifo_size - num_out_fifo_bytes(ines_priv);
                if (num_bytes + count > length)
                        num_bytes = length - count;
                for (i = 0; i < num_bytes; i++)
                        write_byte(nec_priv, buffer[count++], CDOR);
        }
        if (retval < 0) {
                ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
                ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
                *bytes_written = length - num_out_fifo_bytes(ines_priv);
                return retval;
        }
        // wait last byte has been sent
        retval = ines_write_wait(board, ines_priv, 1);
        ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
        ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
        *bytes_written = length - num_out_fifo_bytes(ines_priv);

        return retval;
}

static irqreturn_t ines_pci_interrupt(int irq, void *arg)
{
        struct gpib_board *board = arg;
        struct ines_priv *priv = board->private_data;
        struct nec7210_priv *nec_priv = &priv->nec7210_priv;

        if (priv->pci_chip_type == PCI_CHIP_QUANCOM) {
                if ((inb(nec_priv->iobase +
                         QUANCOM_IRQ_CONTROL_STATUS_REG) &
                     QUANCOM_IRQ_ASSERTED_BIT))
                        outb(QUANCOM_IRQ_ENABLE_BIT, nec_priv->iobase +
                             QUANCOM_IRQ_CONTROL_STATUS_REG);
        }

        return ines_interrupt(board);
}

static irqreturn_t ines_interrupt(struct gpib_board *board)
{
        struct ines_priv *priv = board->private_data;
        struct nec7210_priv *nec_priv = &priv->nec7210_priv;
        unsigned int isr3_bits, isr4_bits;
        unsigned long flags;
        int wake = 0;

        spin_lock_irqsave(&board->spinlock, flags);

        nec7210_interrupt(board, nec_priv);
        if (priv->pci_chip_type == PCI_CHIP_INES_72130)
                goto out;
        isr3_bits = ines_inb(priv, ISR3);
        isr4_bits = ines_inb(priv, ISR4);
        if (isr3_bits & IFC_ACTIVE_BIT) {
                push_gpib_event(board, EVENT_IFC);
                wake++;
        }
        if (isr3_bits & FIFO_ERROR_BIT)
                dev_err(board->gpib_dev, "fifo error\n");
        if (isr3_bits & XFER_COUNT_BIT)
                wake++;

        if (isr4_bits & (IN_FIFO_WATERMARK_BIT | IN_FIFO_FULL_BIT | OUT_FIFO_WATERMARK_BIT |
                         OUT_FIFO_EMPTY_BIT))
                wake++;

        if (wake)
                wake_up_interruptible(&board->wait);
out:
        spin_unlock_irqrestore(&board->spinlock, flags);
        return IRQ_HANDLED;
}

static int ines_pci_attach(struct gpib_board *board, const struct gpib_board_config *config);
static int ines_pci_xl_attach(struct gpib_board *board, const struct gpib_board_config *config);
static int ines_pci_accel_attach(struct gpib_board *board, const struct gpib_board_config *config);
static int ines_isa_attach(struct gpib_board *board, const struct gpib_board_config *config);

static void ines_pci_detach(struct gpib_board *board);
static void ines_isa_detach(struct gpib_board *board);

enum ines_pci_vendor_ids {
        PCI_VENDOR_ID_INES_QUICKLOGIC = 0x16da
};

enum ines_pci_device_ids {
        PCI_DEVICE_ID_INES_GPIB_AMCC = 0x8507,
        PCI_DEVICE_ID_INES_GPIB_QL5030 = 0x11,
};

enum ines_pci_subdevice_ids {
        PCI_SUBDEVICE_ID_INES_GPIB = 0x1072
};

static struct pci_device_id ines_pci_table[] = {
        {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_PLX,
         PCI_SUBDEVICE_ID_INES_GPIB, 0, 0, 0},
        {PCI_VENDOR_ID_AMCC, PCI_DEVICE_ID_INES_GPIB_AMCC, PCI_VENDOR_ID_AMCC,
         PCI_SUBDEVICE_ID_INES_GPIB, 0, 0, 0},
        {PCI_VENDOR_ID_INES_QUICKLOGIC, PCI_DEVICE_ID_INES_GPIB_QL5030,
         PCI_VENDOR_ID_INES_QUICKLOGIC, PCI_DEVICE_ID_INES_GPIB_QL5030, 0, 0, 0},
        {PCI_DEVICE(PCI_VENDOR_ID_QUANCOM, PCI_DEVICE_ID_QUANCOM_GPIB)},
        {0}
};
MODULE_DEVICE_TABLE(pci, ines_pci_table);

struct ines_pci_id {
        unsigned int vendor_id;
        unsigned int device_id;
        int subsystem_vendor_id;
        int subsystem_device_id;
        unsigned int gpib_region;
        unsigned int io_offset;
        enum ines_pci_chip pci_chip_type;
};

static struct ines_pci_id pci_ids[] = {
        {.vendor_id = PCI_VENDOR_ID_PLX,
         .device_id = PCI_DEVICE_ID_PLX_9050,
         .subsystem_vendor_id = PCI_VENDOR_ID_PLX,
         .subsystem_device_id = PCI_SUBDEVICE_ID_INES_GPIB,
         .gpib_region = 2,
         .io_offset = 1,
         .pci_chip_type = PCI_CHIP_PLX9050,
        },
        {.vendor_id = PCI_VENDOR_ID_AMCC,
         .device_id = PCI_DEVICE_ID_INES_GPIB_AMCC,
         .subsystem_vendor_id = PCI_VENDOR_ID_AMCC,
         .subsystem_device_id = PCI_SUBDEVICE_ID_INES_GPIB,
         .gpib_region = 1,
         .io_offset = 1,
         .pci_chip_type = PCI_CHIP_AMCC5920,
        },
        {.vendor_id = PCI_VENDOR_ID_INES_QUICKLOGIC,
         .device_id = PCI_DEVICE_ID_INES_GPIB_QL5030,
         .subsystem_vendor_id = PCI_VENDOR_ID_INES_QUICKLOGIC,
         .subsystem_device_id = PCI_DEVICE_ID_INES_GPIB_QL5030,
         .gpib_region = 1,
         .io_offset = 1,
         .pci_chip_type = PCI_CHIP_QUICKLOGIC5030,
        },
        {.vendor_id = PCI_VENDOR_ID_QUANCOM,
         .device_id = PCI_DEVICE_ID_QUANCOM_GPIB,
         .subsystem_vendor_id = -1,
         .subsystem_device_id = -1,
         .gpib_region = 0,
         .io_offset = 4,
         .pci_chip_type = PCI_CHIP_QUANCOM,
        },
};

static const int num_pci_chips = ARRAY_SIZE(pci_ids);

// wrappers for interface functions
static int ines_read(struct gpib_board *board, u8 *buffer, size_t length,
                     int *end, size_t *bytes_read)
{
        struct ines_priv *priv = board->private_data;
        struct nec7210_priv *nec_priv = &priv->nec7210_priv;
        ssize_t retval;
        int dummy;

        retval = nec7210_read(board, &priv->nec7210_priv, buffer, length, end, bytes_read);
        if (retval < 0) {
                write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);

                set_bit(RFD_HOLDOFF_BN, &nec_priv->state);

                nec7210_read_data_in(board, nec_priv, &dummy);
        }
        return retval;
}

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

        return nec7210_write(board, &priv->nec7210_priv, buffer, length, send_eoi, bytes_written);
}

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

        return nec7210_command(board, &priv->nec7210_priv, buffer, length, bytes_written);
}

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

        return nec7210_take_control(board, &priv->nec7210_priv, synchronous);
}

static int ines_go_to_standby(struct gpib_board *board)
{
        struct ines_priv *priv = board->private_data;

        return nec7210_go_to_standby(board, &priv->nec7210_priv);
}

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

        return nec7210_request_system_control(board, &priv->nec7210_priv, request_control);
}

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

        nec7210_interface_clear(board, &priv->nec7210_priv, assert);
}

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

        nec7210_remote_enable(board, &priv->nec7210_priv, enable);
}

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

        return nec7210_enable_eos(board, &priv->nec7210_priv, eos_byte, compare_8_bits);
}

static void ines_disable_eos(struct gpib_board *board)
{
        struct ines_priv *priv = board->private_data;

        nec7210_disable_eos(board, &priv->nec7210_priv);
}

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

        return nec7210_update_status(board, &priv->nec7210_priv, clear_mask);
}

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

        return nec7210_primary_address(board, &priv->nec7210_priv, address);
}

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

        return nec7210_secondary_address(board, &priv->nec7210_priv, address, enable);
}

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

        return nec7210_parallel_poll(board, &priv->nec7210_priv, result);
}

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

        nec7210_parallel_poll_configure(board, &priv->nec7210_priv, config);
}

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

        nec7210_parallel_poll_response(board, &priv->nec7210_priv, ist);
}

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

        nec7210_serial_poll_response(board, &priv->nec7210_priv, status);
}

static u8 ines_serial_poll_status(struct gpib_board *board)
{
        struct ines_priv *priv = board->private_data;

        return nec7210_serial_poll_status(board, &priv->nec7210_priv);
}

static void ines_return_to_local(struct gpib_board *board)
{
        struct ines_priv *priv = board->private_data;

        nec7210_return_to_local(board, &priv->nec7210_priv);
}

static struct gpib_interface ines_pci_unaccel_interface = {
        .name = "ines_pci_unaccel",
        .attach = ines_pci_attach,
        .detach = ines_pci_detach,
        .read = ines_read,
        .write = ines_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static struct gpib_interface ines_pci_xl_interface = {
        .name = "ines_pci_xl",
        .attach = ines_pci_xl_attach,
        .detach = ines_pci_detach,
        .read = ines_read,
        .write = ines_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines72130_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static struct gpib_interface ines_pci_interface = {
        .name = "ines_pci",
        .attach = ines_pci_accel_attach,
        .detach = ines_pci_detach,
        .read = ines_accel_read,
        .write = ines_accel_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static struct gpib_interface ines_pci_accel_interface = {
        .name = "ines_pci_accel",
        .attach = ines_pci_accel_attach,
        .detach = ines_pci_detach,
        .read = ines_accel_read,
        .write = ines_accel_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static struct gpib_interface ines_isa_interface = {
        .name = "ines_isa",
        .attach = ines_isa_attach,
        .detach = ines_isa_detach,
        .read = ines_accel_read,
        .write = ines_accel_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static int ines_allocate_private(struct gpib_board *board)
{
        struct ines_priv *priv;

        board->private_data = kzalloc_obj(struct ines_priv);
        if (!board->private_data)
                return -ENOMEM;
        priv = board->private_data;
        init_nec7210_private(&priv->nec7210_priv);
        return 0;
}

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

static int ines_generic_attach(struct gpib_board *board)
{
        struct ines_priv *ines_priv;
        struct nec7210_priv *nec_priv;
        int retval;

        board->status = 0;

        retval = ines_allocate_private(board);
        if (retval)
                return retval;
        ines_priv = board->private_data;
        nec_priv = &ines_priv->nec7210_priv;
        nec_priv->read_byte = nec7210_ioport_read_byte;
        nec_priv->write_byte = nec7210_ioport_write_byte;
        nec_priv->offset = 1;
        nec_priv->type = IGPIB7210;
        ines_priv->pci_chip_type = PCI_CHIP_NONE;

        return 0;
}

static void ines_online(struct ines_priv *ines_priv, const struct gpib_board *board, int use_accel)
{
        struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;

        /* ines doesn't seem to use internal count register */
        write_byte(nec_priv, ICR | 0, AUXMR);

        write_byte(nec_priv, INES_AUX_XMODE, AUXMR);
        write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);

        set_bit(RFD_HOLDOFF_BN, &nec_priv->state);

        write_byte(nec_priv, INES_AUXD | 0, AUXMR);
        ines_outb(ines_priv, 0, XDMA_CONTROL);
        ines_priv->extend_mode_bits = 0;
        ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
        if (use_accel) {
                ines_outb(ines_priv, 0x80, OUT_FIFO_WATERMARK);
                ines_outb(ines_priv, 0x80, IN_FIFO_WATERMARK);
                ines_outb(ines_priv, IFC_ACTIVE_BIT | ATN_ACTIVE_BIT |
                          FIFO_ERROR_BIT | XFER_COUNT_BIT, IMR3);
                ines_outb(ines_priv, IN_FIFO_WATERMARK_BIT | IN_FIFO_FULL_BIT |
                          OUT_FIFO_WATERMARK_BIT | OUT_FIFO_EMPTY_BIT, IMR4);
        } else {
                nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT | OUT_FIFO_ENABLE_BIT, 0);
                ines_outb(ines_priv, IFC_ACTIVE_BIT | FIFO_ERROR_BIT, IMR3);
                ines_outb(ines_priv, 0, IMR4);
        }

        nec7210_board_online(nec_priv, board);
        if (use_accel)
                nec7210_set_reg_bits(nec_priv, IMR1, HR_DOIE | HR_DIIE, 0);
}

static int ines_common_pci_attach(struct gpib_board *board, const struct gpib_board_config *config)
{
        struct ines_priv *ines_priv;
        struct nec7210_priv *nec_priv;
        int isr_flags = 0;
        int retval;
        struct ines_pci_id found_id;
        unsigned int i;
        struct pci_dev *pdev;

        memset(&found_id, 0, sizeof(found_id));

        retval = ines_generic_attach(board);
        if (retval)
                return retval;

        ines_priv = board->private_data;
        nec_priv = &ines_priv->nec7210_priv;

        // find board
        ines_priv->pci_device = NULL;
        for (i = 0; i < num_pci_chips && !ines_priv->pci_device; i++) {
                pdev = NULL;
                do {
                        if (pci_ids[i].subsystem_vendor_id >= 0 &&
                            pci_ids[i].subsystem_device_id >= 0)
                                pdev = pci_get_subsys(pci_ids[i].vendor_id, pci_ids[i].device_id,
                                                      pci_ids[i].subsystem_vendor_id,
                                                      pci_ids[i].subsystem_device_id, pdev);
                        else
                                pdev = pci_get_device(pci_ids[i].vendor_id, pci_ids[i].device_id,
                                                      pdev);
                        if (!pdev)
                                break;
                        if (config->pci_bus >= 0 && config->pci_bus != pdev->bus->number)
                                continue;
                        if (config->pci_slot >= 0 && config->pci_slot != PCI_SLOT(pdev->devfn))
                                continue;
                        found_id = pci_ids[i];
                        ines_priv->pci_device = pdev;
                        break;
                } while (1);
        }
        if (!ines_priv->pci_device) {
                dev_err(board->gpib_dev, "could not find ines PCI board\n");
                return -1;
        }

        if (pci_enable_device(ines_priv->pci_device)) {
                dev_err(board->gpib_dev, "error enabling pci device\n");
                return -1;
        }

        if (pci_request_regions(ines_priv->pci_device, DRV_NAME))
                return -1;
        nec_priv->iobase = pci_resource_start(ines_priv->pci_device,
                                              found_id.gpib_region);

        ines_priv->pci_chip_type = found_id.pci_chip_type;
        nec_priv->offset = found_id.io_offset;
        switch (ines_priv->pci_chip_type) {
        case PCI_CHIP_PLX9050:
                ines_priv->plx_iobase = pci_resource_start(ines_priv->pci_device, 1);
                break;
        case PCI_CHIP_AMCC5920:
                ines_priv->amcc_iobase = pci_resource_start(ines_priv->pci_device, 0);
                break;
        case PCI_CHIP_QUANCOM:
                break;
        case PCI_CHIP_QUICKLOGIC5030:
                break;
        default:
                dev_err(board->gpib_dev, "unspecified chip type? (bug)\n");
                nec_priv->iobase = 0;
                pci_release_regions(ines_priv->pci_device);
                return -1;
        }

        nec7210_board_reset(nec_priv, board);
#ifdef QUANCOM_PCI
        if (ines_priv->pci_chip_type == PCI_CHIP_QUANCOM) {
                /* change interrupt polarity */
                nec_priv->auxb_bits |= HR_INV;
                ines_outb(ines_priv, nec_priv->auxb_bits, AUXMR);
        }
#endif
        isr_flags |= IRQF_SHARED;
        if (request_irq(ines_priv->pci_device->irq, ines_pci_interrupt, isr_flags,
                        DRV_NAME, board)) {
                dev_err(board->gpib_dev, "can't request IRQ %d\n", ines_priv->pci_device->irq);
                return -1;
        }
        ines_priv->irq = ines_priv->pci_device->irq;

        // enable interrupts on pci chip
        switch (ines_priv->pci_chip_type) {
        case PCI_CHIP_PLX9050:
                outl(PLX9050_LINTR1_EN_BIT | PLX9050_LINTR1_POLARITY_BIT | PLX9050_PCI_INTR_EN_BIT,
                     ines_priv->plx_iobase + PLX9050_INTCSR_REG);
                break;
        case PCI_CHIP_AMCC5920:
        {
                static const int region = 1;
                static const int num_wait_states = 7;
                u32 bits;

                bits = amcc_prefetch_bits(region, PREFETCH_DISABLED);
                bits |= amcc_PTADR_mode_bit(region);
                bits |= amcc_disable_write_fifo_bit(region);
                bits |= amcc_wait_state_bits(region, num_wait_states);
                outl(bits, ines_priv->amcc_iobase + AMCC_PASS_THRU_REG);
                outl(AMCC_ADDON_INTR_ENABLE_BIT, ines_priv->amcc_iobase + AMCC_INTCS_REG);
        }
        break;
        case PCI_CHIP_QUANCOM:
                outb(QUANCOM_IRQ_ENABLE_BIT, nec_priv->iobase +
                     QUANCOM_IRQ_CONTROL_STATUS_REG);
                break;
        case PCI_CHIP_QUICKLOGIC5030:
                break;
        default:
                dev_err(board->gpib_dev, "unspecified chip type? (bug)\n");
                return -1;
        }

        return 0;
}

static int ines_pci_attach(struct gpib_board *board, const struct gpib_board_config *config)
{
        struct ines_priv *ines_priv;
        int retval;

        retval = ines_common_pci_attach(board, config);
        if (retval < 0)
                return retval;

        ines_priv = board->private_data;
        ines_online(ines_priv, board, 0);

        return 0;
}

static int ines_pci_xl_attach(struct gpib_board *board, const struct gpib_board_config *config)
{
        struct ines_priv *ines_priv;
        struct nec7210_priv *nec_priv;
        int retval;

        retval = ines_common_pci_attach(board, config);
        if (retval < 0)
                return retval;

        ines_priv = board->private_data;
        ines_priv->pci_chip_type = PCI_CHIP_INES_72130;
        nec_priv = &ines_priv->nec7210_priv;
        nec7210_board_online(nec_priv, board);

        return 0;
}

static int ines_pci_accel_attach(struct gpib_board *board, const struct gpib_board_config *config)
{
        struct ines_priv *ines_priv;
        int retval;

        retval = ines_common_pci_attach(board, config);
        if (retval < 0)
                return retval;

        ines_priv = board->private_data;
        ines_online(ines_priv, board, 1);

        return 0;
}

static const int ines_isa_iosize = 0x20;

static int ines_isa_attach(struct gpib_board *board, const struct gpib_board_config *config)
{
        struct ines_priv *ines_priv;
        struct nec7210_priv *nec_priv;
        int isr_flags = 0;
        int retval;

        retval = ines_generic_attach(board);
        if (retval)
                return retval;

        ines_priv = board->private_data;
        nec_priv = &ines_priv->nec7210_priv;

        if (!request_region(config->ibbase, ines_isa_iosize, DRV_NAME)) {
                dev_err(board->gpib_dev, "ioports at 0x%x already in use\n",
                        config->ibbase);
                return -EBUSY;
        }
        nec_priv->iobase = config->ibbase;
        nec_priv->offset = 1;
        nec7210_board_reset(nec_priv, board);
        if (request_irq(config->ibirq, ines_pci_interrupt, isr_flags, DRV_NAME, board)) {
                dev_err(board->gpib_dev, "failed to allocate IRQ %d\n", config->ibirq);
                return -1;
        }
        ines_priv->irq = config->ibirq;
        ines_online(ines_priv, board, 1);
        return 0;
}

static void ines_pci_detach(struct gpib_board *board)
{
        struct ines_priv *ines_priv = board->private_data;
        struct nec7210_priv *nec_priv;

        if (ines_priv) {
                nec_priv = &ines_priv->nec7210_priv;
                if (ines_priv->irq) {
                        // disable interrupts
                        switch (ines_priv->pci_chip_type) {
                        case PCI_CHIP_AMCC5920:
                                if (ines_priv->plx_iobase)
                                        outl(0, ines_priv->plx_iobase + PLX9050_INTCSR_REG);
                                break;
                        case PCI_CHIP_QUANCOM:
                                if (nec_priv->iobase)
                                        outb(0, nec_priv->iobase +
                                             QUANCOM_IRQ_CONTROL_STATUS_REG);
                                break;
                        default:
                                break;
                        }
                        free_irq(ines_priv->irq, board);
                }
                if (nec_priv->iobase) {
                        nec7210_board_reset(nec_priv, board);
                        pci_release_regions(ines_priv->pci_device);
                }
                if (ines_priv->pci_device)
                        pci_dev_put(ines_priv->pci_device);
        }
        ines_free_private(board);
}

static void ines_isa_detach(struct gpib_board *board)
{
        struct ines_priv *ines_priv = board->private_data;
        struct nec7210_priv *nec_priv;

        if (ines_priv) {
                nec_priv = &ines_priv->nec7210_priv;
                if (ines_priv->irq)
                        free_irq(ines_priv->irq, board);
                if (nec_priv->iobase) {
                        nec7210_board_reset(nec_priv, board);
                        release_region(nec_priv->iobase, ines_isa_iosize);
                }
        }
        ines_free_private(board);
}

static int ines_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
        return 0;
}

static struct pci_driver ines_pci_driver = {
        .name = "ines_gpib",
        .id_table = ines_pci_table,
        .probe = &ines_pci_probe
};

#ifdef CONFIG_GPIB_PCMCIA

#include <linux/kernel.h>
#include <linux/ptrace.h>
#include <linux/string.h>
#include <linux/timer.h>

#include <pcmcia/cistpl.h>
#include <pcmcia/ds.h>
#include <pcmcia/cisreg.h>

static const int ines_pcmcia_iosize = 0x20;

/*
 * The event() function is this driver's Card Services event handler.
 * It will be called by Card Services when an appropriate card status
 * event is received.  The config() and release() entry points are
 * used to configure or release a socket, in response to card insertion
 * and ejection events.  They are invoked from the gpib event
 * handler.
 */

static int ines_gpib_config(struct pcmcia_device  *link);
static void ines_gpib_release(struct pcmcia_device  *link);
static int ines_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config);
static int ines_pcmcia_accel_attach(struct gpib_board *board,
                                    const struct gpib_board_config *config);
static void ines_pcmcia_detach(struct gpib_board *board);
static int ines_common_pcmcia_attach(struct gpib_board *board);
/*
 * A linked list of "instances" of the gpib device.  Each actual
 * PCMCIA card corresponds to one device instance, and is described
 * by one dev_link_t structure (defined in ds.h).
 *
 * You may not want to use a linked list for this -- for example, the
 * memory card driver uses an array of dev_link_t pointers, where minor
 * device numbers are used to derive the corresponding array index.
 */

static struct pcmcia_device *curr_dev;

/*
 * A dev_link_t structure has fields for most things that are needed
 * to keep track of a socket, but there will usually be some device
 * specific information that also needs to be kept track of.  The
 * 'priv' pointer in a dev_link_t structure can be used to point to
 * a device-specific private data structure, like this.
 *
 * A driver needs to provide a dev_node_t structure for each device
 * on a card.   In some cases, there is only one device per card (for
 * example, ethernet cards, modems).  In other cases, there may be
 * many actual or logical devices (SCSI adapters, memory cards with
 * multiple partitions).  The dev_node_t structures need to be kept
 * in a linked list starting at the 'dev' field of a dev_link_t
 * structure.   We allocate them in the card's private data structure,
 * because they generally can't be allocated dynamically.
 */

struct local_info {
        struct pcmcia_device    *p_dev;
        struct gpib_board               *dev;
        u_short manfid;
        u_short cardid;
};

/*
 * gpib_attach() creates an "instance" of the driver, allocating
 * local data structures for one device.  The device is registered
 * with Card Services.
 *
 * The dev_link structure is initialized, but we don't actually
 * configure the card at this point -- we wait until we receive a
 * card insertion event.
 */
static int ines_gpib_probe(struct pcmcia_device *link)
{
        struct local_info *info;

//      int ret, i;

        /* Allocate space for private device-specific data */
        info = kzalloc_obj(*info);
        if (!info)
                return -ENOMEM;

        info->p_dev = link;
        link->priv = info;

        /* The io structure describes IO port mapping */
        link->resource[0]->end = 32;
        link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
        link->io_lines = 5;

        /* General socket configuration */
        link->config_flags = CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;

        /* Register with Card Services */
        curr_dev = link;
        return ines_gpib_config(link);
}

/*
 * This deletes a driver "instance".    The device is de-registered
 * with Card Services.  If it has been released, all local data
 * structures are freed.  Otherwise, the structures will be freed
 * when the device is released.
 */
static void ines_gpib_remove(struct pcmcia_device *link)
{
        struct local_info *info = link->priv;
        //struct struct gpib_board *dev = info->dev;

        if (info->dev)
                ines_pcmcia_detach(info->dev);
        ines_gpib_release(link);

        //free_netdev(dev);
        kfree(info);
}

static int ines_gpib_config_iteration(struct pcmcia_device *link, void *priv_data)
{
        return pcmcia_request_io(link);
}

/*
 * gpib_config() is scheduled to run after a CARD_INSERTION event
 * is received, to configure the PCMCIA socket, and to make the
 * device available to the system.
 */
static int ines_gpib_config(struct pcmcia_device *link)
{
        int retval;
        void __iomem *virt;

        retval = pcmcia_loop_config(link, &ines_gpib_config_iteration, NULL);
        if (retval) {
                dev_warn(&link->dev, "no configuration found\n");
                ines_gpib_release(link);
                return -ENODEV;
        }

        dev_dbg(&link->dev, "ines_cs: manufacturer: 0x%x card: 0x%x\n",
                link->manf_id, link->card_id);

        /*
         * for the ines card we have to setup the configuration registers in
         * attribute memory here
         */
        link->resource[2]->flags |= WIN_MEMORY_TYPE_AM | WIN_DATA_WIDTH_8 | WIN_ENABLE;
        link->resource[2]->end = 0x1000;
        retval = pcmcia_request_window(link, link->resource[2], 250);
        if (retval) {
                dev_warn(&link->dev, "pcmcia_request_window failed\n");
                ines_gpib_release(link);
                return -ENODEV;
        }
        retval = pcmcia_map_mem_page(link, link->resource[2], 0);
        if (retval) {
                dev_warn(&link->dev, "pcmcia_map_mem_page failed\n");
                ines_gpib_release(link);
                return -ENODEV;
        }
        virt = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
        writeb((link->resource[2]->start >> 2) & 0xff, virt + 0xf0); // IOWindow base
        iounmap(virt);

        /*
         * This actually configures the PCMCIA socket -- setting up
         * the I/O windows and the interrupt mapping.
         */
        retval = pcmcia_enable_device(link);
        if (retval) {
                ines_gpib_release(link);
                return -ENODEV;
        }
        return 0;
} /* gpib_config */

/*
 * After a card is removed, gpib_release() will unregister the net
 * device, and release the PCMCIA configuration.  If the device is
 * still open, this will be postponed until it is closed.
 */

static void ines_gpib_release(struct pcmcia_device *link)
{
        pcmcia_disable_device(link);
} /* gpib_release */

static int ines_gpib_suspend(struct pcmcia_device *link)
{
        //struct local_info *info = link->priv;
        //struct struct gpib_board *dev = info->dev;

        if (link->open)
                dev_err(&link->dev, "Device still open\n");
        //netif_device_detach(dev);

        return 0;
}

static int ines_gpib_resume(struct pcmcia_device *link)
{
        //struct local_info_t *info = link->priv;
        //struct struct gpib_board *dev = info->dev;

        /*if (link->open) {
         *      ni_gpib_probe(dev);     / really?
         *      //netif_device_attach(dev);
         *}
         */
        return ines_gpib_config(link);
}

static struct pcmcia_device_id ines_pcmcia_ids[] = {
        PCMCIA_DEVICE_MANF_CARD(0x01b4, 0x4730),
        PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, ines_pcmcia_ids);

static struct pcmcia_driver ines_gpib_cs_driver = {
        .owner          = THIS_MODULE,
        .name           = "ines_gpib_cs",
        .id_table       = ines_pcmcia_ids,
        .probe          = ines_gpib_probe,
        .remove         = ines_gpib_remove,
        .suspend        = ines_gpib_suspend,
        .resume         = ines_gpib_resume,
};

static void ines_pcmcia_cleanup_module(void)
{
        pcmcia_unregister_driver(&ines_gpib_cs_driver);
}

static struct gpib_interface ines_pcmcia_unaccel_interface = {
        .name = "ines_pcmcia_unaccel",
        .attach = ines_pcmcia_attach,
        .detach = ines_pcmcia_detach,
        .read = ines_read,
        .write = ines_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static struct gpib_interface ines_pcmcia_accel_interface = {
        .name = "ines_pcmcia_accel",
        .attach = ines_pcmcia_accel_attach,
        .detach = ines_pcmcia_detach,
        .read = ines_accel_read,
        .write = ines_accel_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static struct gpib_interface ines_pcmcia_interface = {
        .name = "ines_pcmcia",
        .attach = ines_pcmcia_accel_attach,
        .detach = ines_pcmcia_detach,
        .read = ines_accel_read,
        .write = ines_accel_write,
        .command = ines_command,
        .take_control = ines_take_control,
        .go_to_standby = ines_go_to_standby,
        .request_system_control = ines_request_system_control,
        .interface_clear = ines_interface_clear,
        .remote_enable = ines_remote_enable,
        .enable_eos = ines_enable_eos,
        .disable_eos = ines_disable_eos,
        .parallel_poll = ines_parallel_poll,
        .parallel_poll_configure = ines_parallel_poll_configure,
        .parallel_poll_response = ines_parallel_poll_response,
        .local_parallel_poll_mode = NULL, // XXX
        .line_status = ines_line_status,
        .update_status = ines_update_status,
        .primary_address = ines_primary_address,
        .secondary_address = ines_secondary_address,
        .serial_poll_response = ines_serial_poll_response,
        .serial_poll_status = ines_serial_poll_status,
        .t1_delay = ines_t1_delay,
        .return_to_local = ines_return_to_local,
};

static irqreturn_t ines_pcmcia_interrupt(int irq, void *arg)
{
        struct gpib_board *board = arg;

        return ines_interrupt(board);
}

static int ines_common_pcmcia_attach(struct gpib_board *board)
{
        struct ines_priv *ines_priv;
        struct nec7210_priv *nec_priv;
        int retval;

        if (!curr_dev) {
                dev_err(board->gpib_dev, "no ines pcmcia cards found\n");
                return -1;
        }

        retval = ines_generic_attach(board);
        if (retval)
                return retval;

        ines_priv = board->private_data;
        nec_priv = &ines_priv->nec7210_priv;

        if (!request_region(curr_dev->resource[0]->start,
                            resource_size(curr_dev->resource[0]), DRV_NAME)) {
                dev_err(board->gpib_dev, "ioports at 0x%lx already in use\n",
                        (unsigned long)(curr_dev->resource[0]->start));
                return -1;
        }

        nec_priv->iobase = curr_dev->resource[0]->start;

        nec7210_board_reset(nec_priv, board);

        if (request_irq(curr_dev->irq, ines_pcmcia_interrupt, IRQF_SHARED,
                        "pcmcia-gpib", board))  {
                dev_err(board->gpib_dev, "can't request IRQ %d\n", curr_dev->irq);
                return -1;
        }
        ines_priv->irq = curr_dev->irq;

        return 0;
}

static int ines_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config)
{
        struct ines_priv *ines_priv;
        int retval;

        retval = ines_common_pcmcia_attach(board);
        if (retval < 0)
                return retval;

        ines_priv = board->private_data;
        ines_online(ines_priv, board, 0);

        return 0;
}

static int ines_pcmcia_accel_attach(struct gpib_board *board,
                                    const struct gpib_board_config *config)
{
        struct ines_priv *ines_priv;
        int retval;

        retval = ines_common_pcmcia_attach(board);
        if (retval < 0)
                return retval;

        ines_priv = board->private_data;
        ines_online(ines_priv, board, 1);

        return 0;
}

static void ines_pcmcia_detach(struct gpib_board *board)
{
        struct ines_priv *ines_priv = board->private_data;
        struct nec7210_priv *nec_priv;

        if (ines_priv) {
                nec_priv = &ines_priv->nec7210_priv;
                if (ines_priv->irq)
                        free_irq(ines_priv->irq, board);
                if (nec_priv->iobase) {
                        nec7210_board_reset(nec_priv, board);
                        release_region(nec_priv->iobase, ines_pcmcia_iosize);
                }
        }
        ines_free_private(board);
}

#endif /* CONFIG_GPIB_PCMCIA */

static int __init ines_init_module(void)
{
        int ret;

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

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

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

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

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

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

#ifdef CONFIG_GPIB_PCMCIA
        ret = gpib_register_driver(&ines_pcmcia_interface, THIS_MODULE);
        if (ret) {
                pr_err("gpib_register_driver failed: error = %d\n", ret);
                goto err_pcmcia;
        }

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

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

        ret = pcmcia_register_driver(&ines_gpib_cs_driver);
        if (ret) {
                pr_err("pcmcia_register_driver failed: error = %d\n", ret);
                goto err_pcmcia_driver;
        }
#endif

        return 0;

#ifdef CONFIG_GPIB_PCMCIA
err_pcmcia_driver:
        gpib_unregister_driver(&ines_pcmcia_accel_interface);
err_pcmcia_accel:
        gpib_unregister_driver(&ines_pcmcia_unaccel_interface);
err_pcmcia_unaccel:
        gpib_unregister_driver(&ines_pcmcia_interface);
err_pcmcia:
#endif
        gpib_unregister_driver(&ines_isa_interface);
err_isa:
        gpib_unregister_driver(&ines_pci_accel_interface);
err_pci_accel:
        gpib_unregister_driver(&ines_pci_unaccel_interface);
err_pci_xl:
        gpib_unregister_driver(&ines_pci_xl_interface);
err_pci_unaccel:
        gpib_unregister_driver(&ines_pci_interface);
err_pci:
        pci_unregister_driver(&ines_pci_driver);

        return ret;
}

static void __exit ines_exit_module(void)
{
        gpib_unregister_driver(&ines_pci_interface);
        gpib_unregister_driver(&ines_pci_unaccel_interface);
        gpib_unregister_driver(&ines_pci_xl_interface);
        gpib_unregister_driver(&ines_pci_accel_interface);
        gpib_unregister_driver(&ines_isa_interface);
#ifdef CONFIG_GPIB_PCMCIA
        gpib_unregister_driver(&ines_pcmcia_interface);
        gpib_unregister_driver(&ines_pcmcia_unaccel_interface);
        gpib_unregister_driver(&ines_pcmcia_accel_interface);
        ines_pcmcia_cleanup_module();
#endif

        pci_unregister_driver(&ines_pci_driver);
}

module_init(ines_init_module);
module_exit(ines_exit_module);