diff options
Diffstat (limited to 'drivers/staging/comedi/drivers/gsc_hpdi.c')
-rw-r--r-- | drivers/staging/comedi/drivers/gsc_hpdi.c | 515 |
1 files changed, 207 insertions, 308 deletions
diff --git a/drivers/staging/comedi/drivers/gsc_hpdi.c b/drivers/staging/comedi/drivers/gsc_hpdi.c index abff6603952a..154598f6d5e3 100644 --- a/drivers/staging/comedi/drivers/gsc_hpdi.c +++ b/drivers/staging/comedi/drivers/gsc_hpdi.c @@ -26,24 +26,26 @@ ************************************************************************/ /* + * Driver: gsc_hpdi + * Description: General Standards Corporation High + * Speed Parallel Digital Interface rs485 boards + * Author: Frank Mori Hess <fmhess@users.sourceforge.net> + * Status: only receive mode works, transmit not supported + * Updated: Thu, 01 Nov 2012 16:17:38 +0000 + * Devices: [General Standards Corporation] PCI-HPDI32 (gsc_hpdi), + * PMC-HPDI32 + * + * Configuration options: + * None. + * + * Manual configuration of supported devices is not supported; they are + * configured automatically. + * + * There are some additional hpdi models available from GSC for which + * support could be added to this driver. + */ -Driver: gsc_hpdi -Description: General Standards Corporation High - Speed Parallel Digital Interface rs485 boards -Author: Frank Mori Hess <fmhess@users.sourceforge.net> -Status: only receive mode works, transmit not supported -Updated: 2003-02-20 -Devices: [General Standards Corporation] PCI-HPDI32 (gsc_hpdi), - PMC-HPDI32 - -Configuration options: - [0] - PCI bus of device (optional) - [1] - PCI slot of device (optional) - -There are some additional hpdi models available from GSC for which -support could be added to this driver. - -*/ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/interrupt.h> #include "../comedidev.h" @@ -64,9 +66,9 @@ static int dio_config_block_size(struct comedi_device *dev, unsigned int *data); /* #define HPDI_DEBUG enable debugging code */ #ifdef HPDI_DEBUG -#define DEBUG_PRINT(format, args...) printk(format , ## args) +#define DEBUG_PRINT(format, args...) pr_debug(format , ## args) #else -#define DEBUG_PRINT(format, args...) +#define DEBUG_PRINT(format, args...) no_printk(pr_fmt(format), ## args) #endif #define TIMER_BASE 50 /* 20MHz master clock */ @@ -104,35 +106,11 @@ enum hpdi_registers { INTERRUPT_POLARITY_REG = 0x54, }; -int command_channel_valid(unsigned int channel) -{ - if (channel == 0 || channel > 6) { - printk(KERN_WARNING - "gsc_hpdi: bug! invalid cable command channel\n"); - return 0; - } - return 1; -} - /* bit definitions */ enum firmware_revision_bits { FEATURES_REG_PRESENT_BIT = 0x8000, }; -int firmware_revision(uint32_t fwr_bits) -{ - return fwr_bits & 0xff; -} - -int pcb_revision(uint32_t fwr_bits) -{ - return (fwr_bits >> 8) & 0xff; -} - -int hpdi_subid(uint32_t fwr_bits) -{ - return (fwr_bits >> 16) & 0xff; -} enum board_control_bits { BOARD_RESET_BIT = 0x1, /* wait 10usec before accessing fifos */ @@ -147,22 +125,6 @@ enum board_control_bits { CABLE_THROTTLE_ENABLE_BIT = 0x20, TEST_MODE_ENABLE_BIT = 0x80000000, }; -uint32_t command_discrete_output_bits(unsigned int channel, int output, - int output_value) -{ - uint32_t bits = 0; - - if (command_channel_valid(channel) == 0) - return 0; - if (output) { - bits |= 0x1 << (16 + channel); - if (output_value) - bits |= 0x1 << (24 + channel); - } else - bits |= 0x1 << (24 + channel); - - return bits; -} enum board_status_bits { COMMAND_LINE_STATUS_MASK = 0x7f, @@ -182,28 +144,17 @@ enum board_status_bits { RX_OVERRUN_BIT = 0x800000, }; -uint32_t almost_full_bits(unsigned int num_words) +static uint32_t almost_full_bits(unsigned int num_words) { -/* XXX need to add or subtract one? */ + /* XXX need to add or subtract one? */ return (num_words << 16) & 0xff0000; } -uint32_t almost_empty_bits(unsigned int num_words) +static uint32_t almost_empty_bits(unsigned int num_words) { return num_words & 0xffff; } -unsigned int almost_full_num_words(uint32_t bits) -{ -/* XXX need to add or subtract one? */ - return (bits >> 16) & 0xffff; -} - -unsigned int almost_empty_num_words(uint32_t bits) -{ - return bits & 0xffff; -} - enum features_bits { FIFO_SIZE_PRESENT_BIT = 0x1, FIFO_WORDS_PRESENT_BIT = 0x2, @@ -225,46 +176,19 @@ enum interrupt_sources { RX_ALMOST_FULL_INTR = 14, RX_FULL_INTR = 15, }; -int command_intr_source(unsigned int channel) -{ - if (command_channel_valid(channel) == 0) - channel = 1; - return channel + 1; -} -uint32_t intr_bit(int interrupt_source) +static uint32_t intr_bit(int interrupt_source) { return 0x1 << interrupt_source; } -uint32_t tx_clock_divisor_bits(unsigned int divisor) -{ - return divisor & 0xff; -} - -unsigned int fifo_size(uint32_t fifo_size_bits) +static unsigned int fifo_size(uint32_t fifo_size_bits) { return fifo_size_bits & 0xfffff; } -unsigned int fifo_words(uint32_t fifo_words_bits) -{ - return fifo_words_bits & 0xfffff; -} - -uint32_t intr_edge_bit(int interrupt_source) -{ - return 0x1 << interrupt_source; -} - -uint32_t intr_active_high_bit(int interrupt_source) -{ - return 0x1 << interrupt_source; -} - struct hpdi_board { - - char *name; + const char *name; /* board name */ int device_id; /* pci device id */ int subdevice_id; /* pci subdevice id */ }; @@ -284,17 +208,7 @@ static const struct hpdi_board hpdi_boards[] = { #endif }; -static inline struct hpdi_board *board(const struct comedi_device *dev) -{ - return (struct hpdi_board *)dev->board_ptr; -} - struct hpdi_private { - - struct pci_dev *hw_dev; /* pointer to board's pci_dev struct */ - /* base addresses (physical) */ - resource_size_t plx9080_phys_iobase; - resource_size_t hpdi_phys_iobase; /* base addresses (ioremapped) */ void __iomem *plx9080_iobase; void __iomem *hpdi_iobase; @@ -321,27 +235,24 @@ struct hpdi_private { unsigned dio_config_output:1; }; -static inline struct hpdi_private *priv(struct comedi_device *dev) -{ - return dev->private; -} - static int dio_config_insn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { + struct hpdi_private *devpriv = dev->private; + switch (data[0]) { case INSN_CONFIG_DIO_OUTPUT: - priv(dev)->dio_config_output = 1; + devpriv->dio_config_output = 1; return insn->n; break; case INSN_CONFIG_DIO_INPUT: - priv(dev)->dio_config_output = 0; + devpriv->dio_config_output = 0; return insn->n; break; case INSN_CONFIG_DIO_QUERY: data[1] = - priv(dev)->dio_config_output ? COMEDI_OUTPUT : COMEDI_INPUT; + devpriv->dio_config_output ? COMEDI_OUTPUT : COMEDI_INPUT; return insn->n; break; case INSN_CONFIG_BLOCK_SIZE: @@ -356,21 +267,24 @@ static int dio_config_insn(struct comedi_device *dev, static void disable_plx_interrupts(struct comedi_device *dev) { - writel(0, priv(dev)->plx9080_iobase + PLX_INTRCS_REG); + struct hpdi_private *devpriv = dev->private; + + writel(0, devpriv->plx9080_iobase + PLX_INTRCS_REG); } /* initialize plx9080 chip */ static void init_plx9080(struct comedi_device *dev) { + struct hpdi_private *devpriv = dev->private; uint32_t bits; - void __iomem *plx_iobase = priv(dev)->plx9080_iobase; + void __iomem *plx_iobase = devpriv->plx9080_iobase; /* plx9080 dump */ DEBUG_PRINT(" plx interrupt status 0x%x\n", readl(plx_iobase + PLX_INTRCS_REG)); DEBUG_PRINT(" plx id bits 0x%x\n", readl(plx_iobase + PLX_ID_REG)); DEBUG_PRINT(" plx control reg 0x%x\n", - readl(priv(dev)->plx9080_iobase + PLX_CONTROL_REG)); + readl(devpriv->plx9080_iobase + PLX_CONTROL_REG)); DEBUG_PRINT(" plx revision 0x%x\n", readl(plx_iobase + PLX_REVISION_REG)); @@ -396,7 +310,7 @@ static void init_plx9080(struct comedi_device *dev) #else bits = 0; #endif - writel(bits, priv(dev)->plx9080_iobase + PLX_BIGEND_REG); + writel(bits, devpriv->plx9080_iobase + PLX_BIGEND_REG); disable_plx_interrupts(dev); @@ -457,28 +371,29 @@ static int setup_subdevices(struct comedi_device *dev) static int init_hpdi(struct comedi_device *dev) { + struct hpdi_private *devpriv = dev->private; uint32_t plx_intcsr_bits; - writel(BOARD_RESET_BIT, priv(dev)->hpdi_iobase + BOARD_CONTROL_REG); + writel(BOARD_RESET_BIT, devpriv->hpdi_iobase + BOARD_CONTROL_REG); udelay(10); writel(almost_empty_bits(32) | almost_full_bits(32), - priv(dev)->hpdi_iobase + RX_PROG_ALMOST_REG); + devpriv->hpdi_iobase + RX_PROG_ALMOST_REG); writel(almost_empty_bits(32) | almost_full_bits(32), - priv(dev)->hpdi_iobase + TX_PROG_ALMOST_REG); + devpriv->hpdi_iobase + TX_PROG_ALMOST_REG); - priv(dev)->tx_fifo_size = fifo_size(readl(priv(dev)->hpdi_iobase + + devpriv->tx_fifo_size = fifo_size(readl(devpriv->hpdi_iobase + TX_FIFO_SIZE_REG)); - priv(dev)->rx_fifo_size = fifo_size(readl(priv(dev)->hpdi_iobase + + devpriv->rx_fifo_size = fifo_size(readl(devpriv->hpdi_iobase + RX_FIFO_SIZE_REG)); - writel(0, priv(dev)->hpdi_iobase + INTERRUPT_CONTROL_REG); + writel(0, devpriv->hpdi_iobase + INTERRUPT_CONTROL_REG); /* enable interrupts */ plx_intcsr_bits = ICS_AERR | ICS_PERR | ICS_PIE | ICS_PLIE | ICS_PAIE | ICS_LIE | ICS_DMA0_E; - writel(plx_intcsr_bits, priv(dev)->plx9080_iobase + PLX_INTRCS_REG); + writel(plx_intcsr_bits, devpriv->plx9080_iobase + PLX_INTRCS_REG); return 0; } @@ -487,6 +402,7 @@ static int init_hpdi(struct comedi_device *dev) static int setup_dma_descriptors(struct comedi_device *dev, unsigned int transfer_size) { + struct hpdi_private *devpriv = dev->private; unsigned int buffer_index, buffer_offset; uint32_t next_bits = PLX_DESC_IN_PCI_BIT | PLX_INTR_TERM_COUNT | PLX_XFER_LOCAL_TO_PCI; @@ -500,25 +416,25 @@ static int setup_dma_descriptors(struct comedi_device *dev, DEBUG_PRINT(" transfer_size %i\n", transfer_size); DEBUG_PRINT(" descriptors at 0x%lx\n", - (unsigned long)priv(dev)->dma_desc_phys_addr); + (unsigned long)devpriv->dma_desc_phys_addr); buffer_offset = 0; buffer_index = 0; for (i = 0; i < NUM_DMA_DESCRIPTORS && buffer_index < NUM_DMA_BUFFERS; i++) { - priv(dev)->dma_desc[i].pci_start_addr = - cpu_to_le32(priv(dev)->dio_buffer_phys_addr[buffer_index] + + devpriv->dma_desc[i].pci_start_addr = + cpu_to_le32(devpriv->dio_buffer_phys_addr[buffer_index] + buffer_offset); - priv(dev)->dma_desc[i].local_start_addr = cpu_to_le32(FIFO_REG); - priv(dev)->dma_desc[i].transfer_size = + devpriv->dma_desc[i].local_start_addr = cpu_to_le32(FIFO_REG); + devpriv->dma_desc[i].transfer_size = cpu_to_le32(transfer_size); - priv(dev)->dma_desc[i].next = - cpu_to_le32((priv(dev)->dma_desc_phys_addr + (i + + devpriv->dma_desc[i].next = + cpu_to_le32((devpriv->dma_desc_phys_addr + (i + 1) * - sizeof(priv(dev)->dma_desc[0])) | next_bits); + sizeof(devpriv->dma_desc[0])) | next_bits); - priv(dev)->desc_dio_buffer[i] = - priv(dev)->dio_buffer[buffer_index] + + devpriv->desc_dio_buffer[i] = + devpriv->dio_buffer[buffer_index] + (buffer_offset / sizeof(uint32_t)); buffer_offset += transfer_size; @@ -529,128 +445,110 @@ static int setup_dma_descriptors(struct comedi_device *dev, DEBUG_PRINT(" desc %i\n", i); DEBUG_PRINT(" start addr virt 0x%p, phys 0x%lx\n", - priv(dev)->desc_dio_buffer[i], - (unsigned long)priv(dev)->dma_desc[i]. + devpriv->desc_dio_buffer[i], + (unsigned long)devpriv->dma_desc[i]. pci_start_addr); DEBUG_PRINT(" next 0x%lx\n", - (unsigned long)priv(dev)->dma_desc[i].next); + (unsigned long)devpriv->dma_desc[i].next); } - priv(dev)->num_dma_descriptors = i; + devpriv->num_dma_descriptors = i; /* fix last descriptor to point back to first */ - priv(dev)->dma_desc[i - 1].next = - cpu_to_le32(priv(dev)->dma_desc_phys_addr | next_bits); + devpriv->dma_desc[i - 1].next = + cpu_to_le32(devpriv->dma_desc_phys_addr | next_bits); DEBUG_PRINT(" desc %i next fixup 0x%lx\n", i - 1, - (unsigned long)priv(dev)->dma_desc[i - 1].next); + (unsigned long)devpriv->dma_desc[i - 1].next); - priv(dev)->block_size = transfer_size; + devpriv->block_size = transfer_size; return transfer_size; } -static int hpdi_attach(struct comedi_device *dev, struct comedi_devconfig *it) +static const struct hpdi_board *hpdi_find_board(struct pci_dev *pcidev) { - struct pci_dev *pcidev; - int i; - int retval; + unsigned int i; - printk(KERN_WARNING "comedi%d: gsc_hpdi\n", dev->minor); + for (i = 0; i < ARRAY_SIZE(hpdi_boards); i++) + if (pcidev->device == hpdi_boards[i].device_id && + pcidev->subsystem_device == hpdi_boards[i].subdevice_id) + return &hpdi_boards[i]; + return NULL; +} - if (alloc_private(dev, sizeof(struct hpdi_private)) < 0) - return -ENOMEM; +static int hpdi_auto_attach(struct comedi_device *dev, + unsigned long context_unused) +{ + struct pci_dev *pcidev = comedi_to_pci_dev(dev); + const struct hpdi_board *thisboard; + struct hpdi_private *devpriv; + int i; + int retval; - pcidev = NULL; - for (i = 0; i < ARRAY_SIZE(hpdi_boards) && - dev->board_ptr == NULL; i++) { - do { - pcidev = pci_get_subsys(PCI_VENDOR_ID_PLX, - hpdi_boards[i].device_id, - PCI_VENDOR_ID_PLX, - hpdi_boards[i].subdevice_id, - pcidev); - /* was a particular bus/slot requested? */ - if (it->options[0] || it->options[1]) { - /* are we on the wrong bus/slot? */ - if (pcidev->bus->number != it->options[0] || - PCI_SLOT(pcidev->devfn) != it->options[1]) - continue; - } - if (pcidev) { - priv(dev)->hw_dev = pcidev; - dev->board_ptr = hpdi_boards + i; - break; - } - } while (pcidev != NULL); - } - if (dev->board_ptr == NULL) { - printk(KERN_WARNING "gsc_hpdi: no hpdi card found\n"); - return -EIO; + thisboard = hpdi_find_board(pcidev); + if (!thisboard) { + dev_err(dev->class_dev, "gsc_hpdi: pci %s not supported\n", + pci_name(pcidev)); + return -EINVAL; } + dev->board_ptr = thisboard; + dev->board_name = thisboard->name; - printk(KERN_WARNING - "gsc_hpdi: found %s on bus %i, slot %i\n", board(dev)->name, - pcidev->bus->number, PCI_SLOT(pcidev->devfn)); + devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL); + if (!devpriv) + return -ENOMEM; + dev->private = devpriv; - if (comedi_pci_enable(pcidev, dev->driver->driver_name)) { - printk(KERN_WARNING - " failed enable PCI device and request regions\n"); + if (comedi_pci_enable(pcidev, dev->board_name)) { + dev_warn(dev->class_dev, + "failed enable PCI device and request regions\n"); return -EIO; } + dev->iobase = 1; /* the "detach" needs this */ pci_set_master(pcidev); - /* Initialize dev->board_name */ - dev->board_name = board(dev)->name; - - priv(dev)->plx9080_phys_iobase = - pci_resource_start(pcidev, PLX9080_BADDRINDEX); - priv(dev)->hpdi_phys_iobase = - pci_resource_start(pcidev, HPDI_BADDRINDEX); - - /* remap, won't work with 2.0 kernels but who cares */ - priv(dev)->plx9080_iobase = ioremap(priv(dev)->plx9080_phys_iobase, - pci_resource_len(pcidev, - PLX9080_BADDRINDEX)); - priv(dev)->hpdi_iobase = - ioremap(priv(dev)->hpdi_phys_iobase, - pci_resource_len(pcidev, HPDI_BADDRINDEX)); - if (!priv(dev)->plx9080_iobase || !priv(dev)->hpdi_iobase) { - printk(KERN_WARNING " failed to remap io memory\n"); + devpriv->plx9080_iobase = + ioremap(pci_resource_start(pcidev, PLX9080_BADDRINDEX), + pci_resource_len(pcidev, PLX9080_BADDRINDEX)); + devpriv->hpdi_iobase = + ioremap(pci_resource_start(pcidev, HPDI_BADDRINDEX), + pci_resource_len(pcidev, HPDI_BADDRINDEX)); + if (!devpriv->plx9080_iobase || !devpriv->hpdi_iobase) { + dev_warn(dev->class_dev, "failed to remap io memory\n"); return -ENOMEM; } - DEBUG_PRINT(" plx9080 remapped to 0x%p\n", priv(dev)->plx9080_iobase); - DEBUG_PRINT(" hpdi remapped to 0x%p\n", priv(dev)->hpdi_iobase); + DEBUG_PRINT(" plx9080 remapped to 0x%p\n", devpriv->plx9080_iobase); + DEBUG_PRINT(" hpdi remapped to 0x%p\n", devpriv->hpdi_iobase); init_plx9080(dev); /* get irq */ if (request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED, - dev->driver->driver_name, dev)) { - printk(KERN_WARNING - " unable to allocate irq %u\n", pcidev->irq); + dev->board_name, dev)) { + dev_warn(dev->class_dev, + "unable to allocate irq %u\n", pcidev->irq); return -EINVAL; } dev->irq = pcidev->irq; - printk(KERN_WARNING " irq %u\n", dev->irq); + dev_dbg(dev->class_dev, " irq %u\n", dev->irq); /* allocate pci dma buffers */ for (i = 0; i < NUM_DMA_BUFFERS; i++) { - priv(dev)->dio_buffer[i] = - pci_alloc_consistent(priv(dev)->hw_dev, DMA_BUFFER_SIZE, - &priv(dev)->dio_buffer_phys_addr[i]); + devpriv->dio_buffer[i] = + pci_alloc_consistent(pcidev, DMA_BUFFER_SIZE, + &devpriv->dio_buffer_phys_addr[i]); DEBUG_PRINT("dio_buffer at virt 0x%p, phys 0x%lx\n", - priv(dev)->dio_buffer[i], - (unsigned long)priv(dev)->dio_buffer_phys_addr[i]); + devpriv->dio_buffer[i], + (unsigned long)devpriv->dio_buffer_phys_addr[i]); } /* allocate dma descriptors */ - priv(dev)->dma_desc = pci_alloc_consistent(priv(dev)->hw_dev, - sizeof(struct plx_dma_desc) * - NUM_DMA_DESCRIPTORS, - &priv(dev)-> - dma_desc_phys_addr); - if (priv(dev)->dma_desc_phys_addr & 0xf) { - printk(KERN_WARNING - " dma descriptors not quad-word aligned (bug)\n"); + devpriv->dma_desc = pci_alloc_consistent(pcidev, + sizeof(struct plx_dma_desc) * + NUM_DMA_DESCRIPTORS, + &devpriv->dma_desc_phys_addr); + if (devpriv->dma_desc_phys_addr & 0xf) { + dev_warn(dev->class_dev, + " dma descriptors not quad-word aligned (bug)\n"); return -EIO; } @@ -667,39 +565,37 @@ static int hpdi_attach(struct comedi_device *dev, struct comedi_devconfig *it) static void hpdi_detach(struct comedi_device *dev) { + struct pci_dev *pcidev = comedi_to_pci_dev(dev); + struct hpdi_private *devpriv = dev->private; unsigned int i; if (dev->irq) free_irq(dev->irq, dev); - if ((priv(dev)) && (priv(dev)->hw_dev)) { - if (priv(dev)->plx9080_iobase) { + if (devpriv) { + if (devpriv->plx9080_iobase) { disable_plx_interrupts(dev); - iounmap(priv(dev)->plx9080_iobase); + iounmap(devpriv->plx9080_iobase); } - if (priv(dev)->hpdi_iobase) - iounmap(priv(dev)->hpdi_iobase); + if (devpriv->hpdi_iobase) + iounmap(devpriv->hpdi_iobase); /* free pci dma buffers */ for (i = 0; i < NUM_DMA_BUFFERS; i++) { - if (priv(dev)->dio_buffer[i]) - pci_free_consistent(priv(dev)->hw_dev, + if (devpriv->dio_buffer[i]) + pci_free_consistent(pcidev, DMA_BUFFER_SIZE, - priv(dev)-> - dio_buffer[i], - priv - (dev)->dio_buffer_phys_addr - [i]); + devpriv->dio_buffer[i], + devpriv-> + dio_buffer_phys_addr[i]); } /* free dma descriptors */ - if (priv(dev)->dma_desc) - pci_free_consistent(priv(dev)->hw_dev, - sizeof(struct plx_dma_desc) - * NUM_DMA_DESCRIPTORS, - priv(dev)->dma_desc, - priv(dev)-> - dma_desc_phys_addr); - if (priv(dev)->hpdi_phys_iobase) - comedi_pci_disable(priv(dev)->hw_dev); - pci_dev_put(priv(dev)->hw_dev); + if (devpriv->dma_desc) + pci_free_consistent(pcidev, + sizeof(struct plx_dma_desc) * + NUM_DMA_DESCRIPTORS, + devpriv->dma_desc, + devpriv->dma_desc_phys_addr); + if (dev->iobase) + comedi_pci_disable(pcidev); } } @@ -745,29 +641,20 @@ static int di_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s, if (err) return 2; - /* step 3: make sure arguments are trivially compatible */ + /* Step 3: check if arguments are trivially valid */ if (!cmd->chanlist_len) { cmd->chanlist_len = 32; - err++; - } - if (cmd->scan_end_arg != cmd->chanlist_len) { - cmd->scan_end_arg = cmd->chanlist_len; - err++; + err |= -EINVAL; } + err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len); switch (cmd->stop_src) { case TRIG_COUNT: - if (!cmd->stop_arg) { - cmd->stop_arg = 1; - err++; - } + err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1); break; case TRIG_NONE: - if (cmd->stop_arg != 0) { - cmd->stop_arg = 0; - err++; - } + err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0); break; default: break; @@ -803,7 +690,9 @@ static int di_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s, static int hpdi_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_cmd *cmd) { - if (priv(dev)->dio_config_output) + struct hpdi_private *devpriv = dev->private; + + if (devpriv->dio_config_output) return -EINVAL; else return di_cmd_test(dev, s, cmd); @@ -812,12 +701,15 @@ static int hpdi_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s, static inline void hpdi_writel(struct comedi_device *dev, uint32_t bits, unsigned int offset) { - writel(bits | priv(dev)->bits[offset / sizeof(uint32_t)], - priv(dev)->hpdi_iobase + offset); + struct hpdi_private *devpriv = dev->private; + + writel(bits | devpriv->bits[offset / sizeof(uint32_t)], + devpriv->hpdi_iobase + offset); } static int di_cmd(struct comedi_device *dev, struct comedi_subdevice *s) { + struct hpdi_private *devpriv = dev->private; uint32_t bits; unsigned long flags; struct comedi_async *async = s->async; @@ -829,39 +721,39 @@ static int di_cmd(struct comedi_device *dev, struct comedi_subdevice *s) abort_dma(dev, 0); - priv(dev)->dma_desc_index = 0; + devpriv->dma_desc_index = 0; /* These register are supposedly unused during chained dma, * but I have found that left over values from last operation * occasionally cause problems with transfer of first dma * block. Initializing them to zero seems to fix the problem. */ - writel(0, priv(dev)->plx9080_iobase + PLX_DMA0_TRANSFER_SIZE_REG); - writel(0, priv(dev)->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG); - writel(0, priv(dev)->plx9080_iobase + PLX_DMA0_LOCAL_ADDRESS_REG); + writel(0, devpriv->plx9080_iobase + PLX_DMA0_TRANSFER_SIZE_REG); + writel(0, devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG); + writel(0, devpriv->plx9080_iobase + PLX_DMA0_LOCAL_ADDRESS_REG); /* give location of first dma descriptor */ bits = - priv(dev)->dma_desc_phys_addr | PLX_DESC_IN_PCI_BIT | + devpriv->dma_desc_phys_addr | PLX_DESC_IN_PCI_BIT | PLX_INTR_TERM_COUNT | PLX_XFER_LOCAL_TO_PCI; - writel(bits, priv(dev)->plx9080_iobase + PLX_DMA0_DESCRIPTOR_REG); + writel(bits, devpriv->plx9080_iobase + PLX_DMA0_DESCRIPTOR_REG); /* spinlock for plx dma control/status reg */ spin_lock_irqsave(&dev->spinlock, flags); /* enable dma transfer */ writeb(PLX_DMA_EN_BIT | PLX_DMA_START_BIT | PLX_CLEAR_DMA_INTR_BIT, - priv(dev)->plx9080_iobase + PLX_DMA0_CS_REG); + devpriv->plx9080_iobase + PLX_DMA0_CS_REG); spin_unlock_irqrestore(&dev->spinlock, flags); if (cmd->stop_src == TRIG_COUNT) - priv(dev)->dio_count = cmd->stop_arg; + devpriv->dio_count = cmd->stop_arg; else - priv(dev)->dio_count = 1; + devpriv->dio_count = 1; /* clear over/under run status flags */ writel(RX_UNDERRUN_BIT | RX_OVERRUN_BIT, - priv(dev)->hpdi_iobase + BOARD_STATUS_REG); + devpriv->hpdi_iobase + BOARD_STATUS_REG); /* enable interrupts */ writel(intr_bit(RX_FULL_INTR), - priv(dev)->hpdi_iobase + INTERRUPT_CONTROL_REG); + devpriv->hpdi_iobase + INTERRUPT_CONTROL_REG); DEBUG_PRINT("hpdi: starting rx\n"); hpdi_writel(dev, RX_ENABLE_BIT, BOARD_CONTROL_REG); @@ -871,7 +763,9 @@ static int di_cmd(struct comedi_device *dev, struct comedi_subdevice *s) static int hpdi_cmd(struct comedi_device *dev, struct comedi_subdevice *s) { - if (priv(dev)->dio_config_output) + struct hpdi_private *devpriv = dev->private; + + if (devpriv->dio_config_output) return -EINVAL; else return di_cmd(dev, s); @@ -879,6 +773,7 @@ static int hpdi_cmd(struct comedi_device *dev, struct comedi_subdevice *s) static void drain_dma_buffers(struct comedi_device *dev, unsigned int channel) { + struct hpdi_private *devpriv = dev->private; struct comedi_async *async = dev->read_subdev->async; uint32_t next_transfer_addr; int j; @@ -887,37 +782,37 @@ static void drain_dma_buffers(struct comedi_device *dev, unsigned int channel) if (channel) pci_addr_reg = - priv(dev)->plx9080_iobase + PLX_DMA1_PCI_ADDRESS_REG; + devpriv->plx9080_iobase + PLX_DMA1_PCI_ADDRESS_REG; else pci_addr_reg = - priv(dev)->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG; + devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG; /* loop until we have read all the full buffers */ j = 0; for (next_transfer_addr = readl(pci_addr_reg); (next_transfer_addr < - le32_to_cpu(priv(dev)->dma_desc[priv(dev)->dma_desc_index]. + le32_to_cpu(devpriv->dma_desc[devpriv->dma_desc_index]. pci_start_addr) || next_transfer_addr >= - le32_to_cpu(priv(dev)->dma_desc[priv(dev)->dma_desc_index]. - pci_start_addr) + priv(dev)->block_size) - && j < priv(dev)->num_dma_descriptors; j++) { + le32_to_cpu(devpriv->dma_desc[devpriv->dma_desc_index]. + pci_start_addr) + devpriv->block_size) + && j < devpriv->num_dma_descriptors; j++) { /* transfer data from dma buffer to comedi buffer */ - num_samples = priv(dev)->block_size / sizeof(uint32_t); + num_samples = devpriv->block_size / sizeof(uint32_t); if (async->cmd.stop_src == TRIG_COUNT) { - if (num_samples > priv(dev)->dio_count) - num_samples = priv(dev)->dio_count; - priv(dev)->dio_count -= num_samples; + if (num_samples > devpriv->dio_count) + num_samples = devpriv->dio_count; + devpriv->dio_count -= num_samples; } cfc_write_array_to_buffer(dev->read_subdev, - priv(dev)->desc_dio_buffer[priv(dev)-> + devpriv->desc_dio_buffer[devpriv-> dma_desc_index], num_samples * sizeof(uint32_t)); - priv(dev)->dma_desc_index++; - priv(dev)->dma_desc_index %= priv(dev)->num_dma_descriptors; + devpriv->dma_desc_index++; + devpriv->dma_desc_index %= devpriv->num_dma_descriptors; DEBUG_PRINT("next desc addr 0x%lx\n", (unsigned long) - priv(dev)->dma_desc[priv(dev)->dma_desc_index]. + devpriv->dma_desc[devpriv->dma_desc_index]. next); DEBUG_PRINT("pci addr reg 0x%x\n", next_transfer_addr); } @@ -927,6 +822,7 @@ static void drain_dma_buffers(struct comedi_device *dev, unsigned int channel) static irqreturn_t handle_interrupt(int irq, void *d) { struct comedi_device *dev = d; + struct hpdi_private *devpriv = dev->private; struct comedi_subdevice *s = dev->read_subdev; struct comedi_async *async = s->async; uint32_t hpdi_intr_status, hpdi_board_status; @@ -938,26 +834,26 @@ static irqreturn_t handle_interrupt(int irq, void *d) if (!dev->attached) return IRQ_NONE; - plx_status = readl(priv(dev)->plx9080_iobase + PLX_INTRCS_REG); + plx_status = readl(devpriv->plx9080_iobase + PLX_INTRCS_REG); if ((plx_status & (ICS_DMA0_A | ICS_DMA1_A | ICS_LIA)) == 0) return IRQ_NONE; - hpdi_intr_status = readl(priv(dev)->hpdi_iobase + INTERRUPT_STATUS_REG); - hpdi_board_status = readl(priv(dev)->hpdi_iobase + BOARD_STATUS_REG); + hpdi_intr_status = readl(devpriv->hpdi_iobase + INTERRUPT_STATUS_REG); + hpdi_board_status = readl(devpriv->hpdi_iobase + BOARD_STATUS_REG); async->events = 0; if (hpdi_intr_status) { DEBUG_PRINT("hpdi: intr status 0x%x, ", hpdi_intr_status); writel(hpdi_intr_status, - priv(dev)->hpdi_iobase + INTERRUPT_STATUS_REG); + devpriv->hpdi_iobase + INTERRUPT_STATUS_REG); } /* spin lock makes sure no one else changes plx dma control reg */ spin_lock_irqsave(&dev->spinlock, flags); - dma0_status = readb(priv(dev)->plx9080_iobase + PLX_DMA0_CS_REG); + dma0_status = readb(devpriv->plx9080_iobase + PLX_DMA0_CS_REG); if (plx_status & ICS_DMA0_A) { /* dma chan 0 interrupt */ writeb((dma0_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT, - priv(dev)->plx9080_iobase + PLX_DMA0_CS_REG); + devpriv->plx9080_iobase + PLX_DMA0_CS_REG); DEBUG_PRINT("dma0 status 0x%x\n", dma0_status); if (dma0_status & PLX_DMA_EN_BIT) @@ -968,10 +864,10 @@ static irqreturn_t handle_interrupt(int irq, void *d) /* spin lock makes sure no one else changes plx dma control reg */ spin_lock_irqsave(&dev->spinlock, flags); - dma1_status = readb(priv(dev)->plx9080_iobase + PLX_DMA1_CS_REG); + dma1_status = readb(devpriv->plx9080_iobase + PLX_DMA1_CS_REG); if (plx_status & ICS_DMA1_A) { /* XXX *//* dma chan 1 interrupt */ writeb((dma1_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT, - priv(dev)->plx9080_iobase + PLX_DMA1_CS_REG); + devpriv->plx9080_iobase + PLX_DMA1_CS_REG); DEBUG_PRINT("dma1 status 0x%x\n", dma1_status); DEBUG_PRINT(" cleared dma ch1 interrupt\n"); @@ -980,8 +876,8 @@ static irqreturn_t handle_interrupt(int irq, void *d) /* clear possible plx9080 interrupt sources */ if (plx_status & ICS_LDIA) { /* clear local doorbell interrupt */ - plx_bits = readl(priv(dev)->plx9080_iobase + PLX_DBR_OUT_REG); - writel(plx_bits, priv(dev)->plx9080_iobase + PLX_DBR_OUT_REG); + plx_bits = readl(devpriv->plx9080_iobase + PLX_DBR_OUT_REG); + writel(plx_bits, devpriv->plx9080_iobase + PLX_DBR_OUT_REG); DEBUG_PRINT(" cleared local doorbell bits 0x%x\n", plx_bits); } @@ -989,7 +885,7 @@ static irqreturn_t handle_interrupt(int irq, void *d) comedi_error(dev, "rx fifo overrun"); async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR; DEBUG_PRINT("dma0_status 0x%x\n", - (int)readb(priv(dev)->plx9080_iobase + + (int)readb(devpriv->plx9080_iobase + PLX_DMA0_CS_REG)); } @@ -998,7 +894,7 @@ static irqreturn_t handle_interrupt(int irq, void *d) async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR; } - if (priv(dev)->dio_count == 0) + if (devpriv->dio_count == 0) async->events |= COMEDI_CB_EOA; DEBUG_PRINT("board status 0x%x, ", hpdi_board_status); @@ -1013,21 +909,24 @@ static irqreturn_t handle_interrupt(int irq, void *d) static void abort_dma(struct comedi_device *dev, unsigned int channel) { + struct hpdi_private *devpriv = dev->private; unsigned long flags; /* spinlock for plx dma control/status reg */ spin_lock_irqsave(&dev->spinlock, flags); - plx9080_abort_dma(priv(dev)->plx9080_iobase, channel); + plx9080_abort_dma(devpriv->plx9080_iobase, channel); spin_unlock_irqrestore(&dev->spinlock, flags); } static int hpdi_cancel(struct comedi_device *dev, struct comedi_subdevice *s) { + struct hpdi_private *devpriv = dev->private; + hpdi_writel(dev, 0, BOARD_CONTROL_REG); - writel(0, priv(dev)->hpdi_iobase + INTERRUPT_CONTROL_REG); + writel(0, devpriv->hpdi_iobase + INTERRUPT_CONTROL_REG); abort_dma(dev, 0); @@ -1037,17 +936,17 @@ static int hpdi_cancel(struct comedi_device *dev, struct comedi_subdevice *s) static struct comedi_driver gsc_hpdi_driver = { .driver_name = "gsc_hpdi", .module = THIS_MODULE, - .attach = hpdi_attach, + .auto_attach = hpdi_auto_attach, .detach = hpdi_detach, }; -static int __devinit gsc_hpdi_pci_probe(struct pci_dev *dev, +static int gsc_hpdi_pci_probe(struct pci_dev *dev, const struct pci_device_id *ent) { return comedi_pci_auto_config(dev, &gsc_hpdi_driver); } -static void __devexit gsc_hpdi_pci_remove(struct pci_dev *dev) +static void gsc_hpdi_pci_remove(struct pci_dev *dev) { comedi_pci_auto_unconfig(dev); } @@ -1063,7 +962,7 @@ static struct pci_driver gsc_hpdi_pci_driver = { .name = "gsc_hpdi", .id_table = gsc_hpdi_pci_table, .probe = gsc_hpdi_pci_probe, - .remove = __devexit_p(gsc_hpdi_pci_remove) + .remove = gsc_hpdi_pci_remove }; module_comedi_pci_driver(gsc_hpdi_driver, gsc_hpdi_pci_driver); |