drivers/staging/comedi/drivers/gsc_hpdi.c

   1 /*
   2     comedi/drivers/gsc_hpdi.c
   3     This is a driver for the General Standards Corporation High
   4     Speed Parallel Digital Interface rs485 boards.
   5
   6     Author:  Frank Mori Hess <fmhess@users.sourceforge.net>
   7     Copyright (C) 2003 Coherent Imaging Systems
   8
   9     COMEDI - Linux Control and Measurement Device Interface
  10     Copyright (C) 1997-8 David A. Schleef <ds@schleef.org>
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21 */
  22
  23 /*
  24  * Driver: gsc_hpdi
  25  * Description: General Standards Corporation High
  26  *    Speed Parallel Digital Interface rs485 boards
  27  * Author: Frank Mori Hess <fmhess@users.sourceforge.net>
  28  * Status: only receive mode works, transmit not supported
  29  * Updated: Thu, 01 Nov 2012 16:17:38 +0000
  30  * Devices: [General Standards Corporation] PCI-HPDI32 (gsc_hpdi),
  31  *   PMC-HPDI32
  32  *
  33  * Configuration options:
  34  *    None.
  35  *
  36  * Manual configuration of supported devices is not supported; they are
  37  * configured automatically.
  38  *
  39  * There are some additional hpdi models available from GSC for which
  40  * support could be added to this driver.
  41  */
  42
  43 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  44
  45 #include <linux/module.h>
  46 #include <linux/pci.h>
  47 #include <linux/delay.h>
  48 #include <linux/interrupt.h>
  49
  50 #include "../comedidev.h"
  51
  52 #include "plx9080.h"
  53 #include "comedi_fc.h"
  54
  55 static void abort_dma(struct comedi_device *dev, unsigned int channel);
  56 static int hpdi_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
  57 static int hpdi_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
  58                          struct comedi_cmd *cmd);
  59 static int hpdi_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
  60 static irqreturn_t handle_interrupt(int irq, void *d);
  61 static int dio_config_block_size(struct comedi_device *dev, unsigned int *data);
  62
  63 #undef HPDI_DEBUG               /*  disable debugging messages */
  64 /* #define HPDI_DEBUG      enable debugging code */
  65
  66 #ifdef HPDI_DEBUG
  67 #define DEBUG_PRINT(format, args...)  pr_debug(format , ## args)
  68 #else
  69 #define DEBUG_PRINT(format, args...)  no_printk(pr_fmt(format), ## args)
  70 #endif
  71
  72 #define TIMER_BASE 50           /*  20MHz master clock */
  73 #define DMA_BUFFER_SIZE 0x10000
  74 #define NUM_DMA_BUFFERS 4
  75 #define NUM_DMA_DESCRIPTORS 256
  76
  77 enum hpdi_registers {
  78         FIRMWARE_REV_REG = 0x0,
  79         BOARD_CONTROL_REG = 0x4,
  80         BOARD_STATUS_REG = 0x8,
  81         TX_PROG_ALMOST_REG = 0xc,
  82         RX_PROG_ALMOST_REG = 0x10,
  83         FEATURES_REG = 0x14,
  84         FIFO_REG = 0x18,
  85         TX_STATUS_COUNT_REG = 0x1c,
  86         TX_LINE_VALID_COUNT_REG = 0x20,
  87         TX_LINE_INVALID_COUNT_REG = 0x24,
  88         RX_STATUS_COUNT_REG = 0x28,
  89         RX_LINE_COUNT_REG = 0x2c,
  90         INTERRUPT_CONTROL_REG = 0x30,
  91         INTERRUPT_STATUS_REG = 0x34,
  92         TX_CLOCK_DIVIDER_REG = 0x38,
  93         TX_FIFO_SIZE_REG = 0x40,
  94         RX_FIFO_SIZE_REG = 0x44,
  95         TX_FIFO_WORDS_REG = 0x48,
  96         RX_FIFO_WORDS_REG = 0x4c,
  97         INTERRUPT_EDGE_LEVEL_REG = 0x50,
  98         INTERRUPT_POLARITY_REG = 0x54,
  99 };
 100
 101 /* bit definitions */
 102
 103 enum firmware_revision_bits {
 104         FEATURES_REG_PRESENT_BIT = 0x8000,
 105 };
 106
 107 enum board_control_bits {
 108         BOARD_RESET_BIT = 0x1,  /* wait 10usec before accessing fifos */
 109         TX_FIFO_RESET_BIT = 0x2,
 110         RX_FIFO_RESET_BIT = 0x4,
 111         TX_ENABLE_BIT = 0x10,
 112         RX_ENABLE_BIT = 0x20,
 113         DEMAND_DMA_DIRECTION_TX_BIT = 0x40,
 114                 /* for ch 0, ch 1 can only transmit (when present) */
 115         LINE_VALID_ON_STATUS_VALID_BIT = 0x80,
 116         START_TX_BIT = 0x10,
 117         CABLE_THROTTLE_ENABLE_BIT = 0x20,
 118         TEST_MODE_ENABLE_BIT = 0x80000000,
 119 };
 120
 121 enum board_status_bits {
 122         COMMAND_LINE_STATUS_MASK = 0x7f,
 123         TX_IN_PROGRESS_BIT = 0x80,
 124         TX_NOT_EMPTY_BIT = 0x100,
 125         TX_NOT_ALMOST_EMPTY_BIT = 0x200,
 126         TX_NOT_ALMOST_FULL_BIT = 0x400,
 127         TX_NOT_FULL_BIT = 0x800,
 128         RX_NOT_EMPTY_BIT = 0x1000,
 129         RX_NOT_ALMOST_EMPTY_BIT = 0x2000,
 130         RX_NOT_ALMOST_FULL_BIT = 0x4000,
 131         RX_NOT_FULL_BIT = 0x8000,
 132         BOARD_JUMPER0_INSTALLED_BIT = 0x10000,
 133         BOARD_JUMPER1_INSTALLED_BIT = 0x20000,
 134         TX_OVERRUN_BIT = 0x200000,
 135         RX_UNDERRUN_BIT = 0x400000,
 136         RX_OVERRUN_BIT = 0x800000,
 137 };
 138
 139 static uint32_t almost_full_bits(unsigned int num_words)
 140 {
 141         /* XXX need to add or subtract one? */
 142         return (num_words << 16) & 0xff0000;
 143 }
 144
 145 static uint32_t almost_empty_bits(unsigned int num_words)
 146 {
 147         return num_words & 0xffff;
 148 }
 149
 150 enum features_bits {
 151         FIFO_SIZE_PRESENT_BIT = 0x1,
 152         FIFO_WORDS_PRESENT_BIT = 0x2,
 153         LEVEL_EDGE_INTERRUPTS_PRESENT_BIT = 0x4,
 154         GPIO_SUPPORTED_BIT = 0x8,
 155         PLX_DMA_CH1_SUPPORTED_BIT = 0x10,
 156         OVERRUN_UNDERRUN_SUPPORTED_BIT = 0x20,
 157 };
 158
 159 enum interrupt_sources {
 160         FRAME_VALID_START_INTR = 0,
 161         FRAME_VALID_END_INTR = 1,
 162         TX_FIFO_EMPTY_INTR = 8,
 163         TX_FIFO_ALMOST_EMPTY_INTR = 9,
 164         TX_FIFO_ALMOST_FULL_INTR = 10,
 165         TX_FIFO_FULL_INTR = 11,
 166         RX_EMPTY_INTR = 12,
 167         RX_ALMOST_EMPTY_INTR = 13,
 168         RX_ALMOST_FULL_INTR = 14,
 169         RX_FULL_INTR = 15,
 170 };
 171
 172 static uint32_t intr_bit(int interrupt_source)
 173 {
 174         return 0x1 << interrupt_source;
 175 }
 176
 177 static unsigned int fifo_size(uint32_t fifo_size_bits)
 178 {
 179         return fifo_size_bits & 0xfffff;
 180 }
 181
 182 struct hpdi_board {
 183         const char *name;       /*  board name */
 184         int device_id;          /*  pci device id */
 185         int subdevice_id;       /*  pci subdevice id */
 186 };
 187
 188 static const struct hpdi_board hpdi_boards[] = {
 189         {
 190          .name = "pci-hpdi32",
 191          .device_id = PCI_DEVICE_ID_PLX_9080,
 192          .subdevice_id = 0x2400,
 193          },
 194 #if 0
 195         {
 196          .name = "pxi-hpdi32",
 197          .device_id = 0x9656,
 198          .subdevice_id = 0x2705,
 199          },
 200 #endif
 201 };
 202
 203 struct hpdi_private {
 204         /*  base addresses (ioremapped) */
 205         void __iomem *plx9080_iobase;
 206         void __iomem *hpdi_iobase;
 207         uint32_t *dio_buffer[NUM_DMA_BUFFERS];  /*  dma buffers */
 208         /* physical addresses of dma buffers */
 209         dma_addr_t dio_buffer_phys_addr[NUM_DMA_BUFFERS];
 210         /* array of dma descriptors read by plx9080, allocated to get proper
 211          * alignment */
 212         struct plx_dma_desc *dma_desc;
 213         /* physical address of dma descriptor array */
 214         dma_addr_t dma_desc_phys_addr;
 215         unsigned int num_dma_descriptors;
 216         /* pointer to start of buffers indexed by descriptor */
 217         uint32_t *desc_dio_buffer[NUM_DMA_DESCRIPTORS];
 218         /* index of the dma descriptor that is currently being used */
 219         volatile unsigned int dma_desc_index;
 220         unsigned int tx_fifo_size;
 221         unsigned int rx_fifo_size;
 222         volatile unsigned long dio_count;
 223         /* software copies of values written to hpdi registers */
 224         volatile uint32_t bits[24];
 225         /* number of bytes at which to generate COMEDI_CB_BLOCK events */
 226         volatile unsigned int block_size;
 227 };
 228
 229 static int dio_config_insn(struct comedi_device *dev,
 230                            struct comedi_subdevice *s,
 231                            struct comedi_insn *insn,
 232                            unsigned int *data)
 233 {
 234         int ret;
 235
 236         switch (data[0]) {
 237         case INSN_CONFIG_BLOCK_SIZE:
 238                 return dio_config_block_size(dev, data);
 239         default:
 240                 ret = comedi_dio_insn_config(dev, s, insn, data, 0xffffffff);
 241                 if (ret)
 242                         return ret;
 243                 break;
 244         }
 245
 246         return insn->n;
 247 }
 248
 249 static void disable_plx_interrupts(struct comedi_device *dev)
 250 {
 251         struct hpdi_private *devpriv = dev->private;
 252
 253         writel(0, devpriv->plx9080_iobase + PLX_INTRCS_REG);
 254 }
 255
 256 /* initialize plx9080 chip */
 257 static void init_plx9080(struct comedi_device *dev)
 258 {
 259         struct hpdi_private *devpriv = dev->private;
 260         uint32_t bits;
 261         void __iomem *plx_iobase = devpriv->plx9080_iobase;
 262
 263         /*  plx9080 dump */
 264         DEBUG_PRINT(" plx interrupt status 0x%x\n",
 265                     readl(plx_iobase + PLX_INTRCS_REG));
 266         DEBUG_PRINT(" plx id bits 0x%x\n", readl(plx_iobase + PLX_ID_REG));
 267         DEBUG_PRINT(" plx control reg 0x%x\n",
 268                     readl(devpriv->plx9080_iobase + PLX_CONTROL_REG));
 269
 270         DEBUG_PRINT(" plx revision 0x%x\n",
 271                     readl(plx_iobase + PLX_REVISION_REG));
 272         DEBUG_PRINT(" plx dma channel 0 mode 0x%x\n",
 273                     readl(plx_iobase + PLX_DMA0_MODE_REG));
 274         DEBUG_PRINT(" plx dma channel 1 mode 0x%x\n",
 275                     readl(plx_iobase + PLX_DMA1_MODE_REG));
 276         DEBUG_PRINT(" plx dma channel 0 pci address 0x%x\n",
 277                     readl(plx_iobase + PLX_DMA0_PCI_ADDRESS_REG));
 278         DEBUG_PRINT(" plx dma channel 0 local address 0x%x\n",
 279                     readl(plx_iobase + PLX_DMA0_LOCAL_ADDRESS_REG));
 280         DEBUG_PRINT(" plx dma channel 0 transfer size 0x%x\n",
 281                     readl(plx_iobase + PLX_DMA0_TRANSFER_SIZE_REG));
 282         DEBUG_PRINT(" plx dma channel 0 descriptor 0x%x\n",
 283                     readl(plx_iobase + PLX_DMA0_DESCRIPTOR_REG));
 284         DEBUG_PRINT(" plx dma channel 0 command status 0x%x\n",
 285                     readb(plx_iobase + PLX_DMA0_CS_REG));
 286         DEBUG_PRINT(" plx dma channel 0 threshold 0x%x\n",
 287                     readl(plx_iobase + PLX_DMA0_THRESHOLD_REG));
 288         DEBUG_PRINT(" plx bigend 0x%x\n", readl(plx_iobase + PLX_BIGEND_REG));
 289 #ifdef __BIG_ENDIAN
 290         bits = BIGEND_DMA0 | BIGEND_DMA1;
 291 #else
 292         bits = 0;
 293 #endif
 294         writel(bits, devpriv->plx9080_iobase + PLX_BIGEND_REG);
 295
 296         disable_plx_interrupts(dev);
 297
 298         abort_dma(dev, 0);
 299         abort_dma(dev, 1);
 300
 301         /*  configure dma0 mode */
 302         bits = 0;
 303         /*  enable ready input */
 304         bits |= PLX_DMA_EN_READYIN_BIT;
 305         /*  enable dma chaining */
 306         bits |= PLX_EN_CHAIN_BIT;
 307         /*  enable interrupt on dma done
 308          *  (probably don't need this, since chain never finishes) */
 309         bits |= PLX_EN_DMA_DONE_INTR_BIT;
 310         /*  don't increment local address during transfers
 311          *  (we are transferring from a fixed fifo register) */
 312         bits |= PLX_LOCAL_ADDR_CONST_BIT;
 313         /*  route dma interrupt to pci bus */
 314         bits |= PLX_DMA_INTR_PCI_BIT;
 315         /*  enable demand mode */
 316         bits |= PLX_DEMAND_MODE_BIT;
 317         /*  enable local burst mode */
 318         bits |= PLX_DMA_LOCAL_BURST_EN_BIT;
 319         bits |= PLX_LOCAL_BUS_32_WIDE_BITS;
 320         writel(bits, plx_iobase + PLX_DMA0_MODE_REG);
 321 }
 322
 323 /* Allocate and initialize the subdevice structures.
 324  */
 325 static int setup_subdevices(struct comedi_device *dev)
 326 {
 327         struct comedi_subdevice *s;
 328         int ret;
 329
 330         ret = comedi_alloc_subdevices(dev, 1);
 331         if (ret)
 332                 return ret;
 333
 334         s = &dev->subdevices[0];
 335         /* analog input subdevice */
 336         dev->read_subdev = s;
 337 /*      dev->write_subdev = s; */
 338         s->type = COMEDI_SUBD_DIO;
 339         s->subdev_flags =
 340             SDF_READABLE | SDF_WRITEABLE | SDF_LSAMPL | SDF_CMD_READ;
 341         s->n_chan = 32;
 342         s->len_chanlist = 32;
 343         s->maxdata = 1;
 344         s->range_table = &range_digital;
 345         s->insn_config = dio_config_insn;
 346         s->do_cmd = hpdi_cmd;
 347         s->do_cmdtest = hpdi_cmd_test;
 348         s->cancel = hpdi_cancel;
 349
 350         return 0;
 351 }
 352
 353 static int init_hpdi(struct comedi_device *dev)
 354 {
 355         struct hpdi_private *devpriv = dev->private;
 356         uint32_t plx_intcsr_bits;
 357
 358         writel(BOARD_RESET_BIT, devpriv->hpdi_iobase + BOARD_CONTROL_REG);
 359         udelay(10);
 360
 361         writel(almost_empty_bits(32) | almost_full_bits(32),
 362                devpriv->hpdi_iobase + RX_PROG_ALMOST_REG);
 363         writel(almost_empty_bits(32) | almost_full_bits(32),
 364                devpriv->hpdi_iobase + TX_PROG_ALMOST_REG);
 365
 366         devpriv->tx_fifo_size = fifo_size(readl(devpriv->hpdi_iobase +
 367                                                   TX_FIFO_SIZE_REG));
 368         devpriv->rx_fifo_size = fifo_size(readl(devpriv->hpdi_iobase +
 369                                                   RX_FIFO_SIZE_REG));
 370
 371         writel(0, devpriv->hpdi_iobase + INTERRUPT_CONTROL_REG);
 372
 373         /*  enable interrupts */
 374         plx_intcsr_bits =
 375             ICS_AERR | ICS_PERR | ICS_PIE | ICS_PLIE | ICS_PAIE | ICS_LIE |
 376             ICS_DMA0_E;
 377         writel(plx_intcsr_bits, devpriv->plx9080_iobase + PLX_INTRCS_REG);
 378
 379         return 0;
 380 }
 381
 382 /* setup dma descriptors so a link completes every 'transfer_size' bytes */
 383 static int setup_dma_descriptors(struct comedi_device *dev,
 384                                  unsigned int transfer_size)
 385 {
 386         struct hpdi_private *devpriv = dev->private;
 387         unsigned int buffer_index, buffer_offset;
 388         uint32_t next_bits = PLX_DESC_IN_PCI_BIT | PLX_INTR_TERM_COUNT |
 389             PLX_XFER_LOCAL_TO_PCI;
 390         unsigned int i;
 391
 392         if (transfer_size > DMA_BUFFER_SIZE)
 393                 transfer_size = DMA_BUFFER_SIZE;
 394         transfer_size -= transfer_size % sizeof(uint32_t);
 395         if (transfer_size == 0)
 396                 return -1;
 397
 398         DEBUG_PRINT(" transfer_size %i\n", transfer_size);
 399         DEBUG_PRINT(" descriptors at 0x%lx\n",
 400                     (unsigned long)devpriv->dma_desc_phys_addr);
 401
 402         buffer_offset = 0;
 403         buffer_index = 0;
 404         for (i = 0; i < NUM_DMA_DESCRIPTORS &&
 405              buffer_index < NUM_DMA_BUFFERS; i++) {
 406                 devpriv->dma_desc[i].pci_start_addr =
 407                     cpu_to_le32(devpriv->dio_buffer_phys_addr[buffer_index] +
 408                                 buffer_offset);
 409                 devpriv->dma_desc[i].local_start_addr = cpu_to_le32(FIFO_REG);
 410                 devpriv->dma_desc[i].transfer_size =
 411                     cpu_to_le32(transfer_size);
 412                 devpriv->dma_desc[i].next =
 413                     cpu_to_le32((devpriv->dma_desc_phys_addr + (i +
 414                                                                   1) *
 415                                  sizeof(devpriv->dma_desc[0])) | next_bits);
 416
 417                 devpriv->desc_dio_buffer[i] =
 418                     devpriv->dio_buffer[buffer_index] +
 419                     (buffer_offset / sizeof(uint32_t));
 420
 421                 buffer_offset += transfer_size;
 422                 if (transfer_size + buffer_offset > DMA_BUFFER_SIZE) {
 423                         buffer_offset = 0;
 424                         buffer_index++;
 425                 }
 426
 427                 DEBUG_PRINT(" desc %i\n", i);
 428                 DEBUG_PRINT(" start addr virt 0x%p, phys 0x%lx\n",
 429                             devpriv->desc_dio_buffer[i],
 430                             (unsigned long)devpriv->dma_desc[i].
 431                             pci_start_addr);
 432                 DEBUG_PRINT(" next 0x%lx\n",
 433                             (unsigned long)devpriv->dma_desc[i].next);
 434         }
 435         devpriv->num_dma_descriptors = i;
 436         /*  fix last descriptor to point back to first */
 437         devpriv->dma_desc[i - 1].next =
 438             cpu_to_le32(devpriv->dma_desc_phys_addr | next_bits);
 439         DEBUG_PRINT(" desc %i next fixup 0x%lx\n", i - 1,
 440                     (unsigned long)devpriv->dma_desc[i - 1].next);
 441
 442         devpriv->block_size = transfer_size;
 443
 444         return transfer_size;
 445 }
 446
 447 static const struct hpdi_board *hpdi_find_board(struct pci_dev *pcidev)
 448 {
 449         unsigned int i;
 450
 451         for (i = 0; i < ARRAY_SIZE(hpdi_boards); i++)
 452                 if (pcidev->device == hpdi_boards[i].device_id &&
 453                     pcidev->subsystem_device == hpdi_boards[i].subdevice_id)
 454                         return &hpdi_boards[i];
 455         return NULL;
 456 }
 457
 458 static int hpdi_auto_attach(struct comedi_device *dev,
 459                                       unsigned long context_unused)
 460 {
 461         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
 462         const struct hpdi_board *thisboard;
 463         struct hpdi_private *devpriv;
 464         int i;
 465         int retval;
 466
 467         thisboard = hpdi_find_board(pcidev);
 468         if (!thisboard) {
 469                 dev_err(dev->class_dev, "gsc_hpdi: pci %s not supported\n",
 470                         pci_name(pcidev));
 471                 return -EINVAL;
 472         }
 473         dev->board_ptr = thisboard;
 474         dev->board_name = thisboard->name;
 475
 476         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
 477         if (!devpriv)
 478                 return -ENOMEM;
 479
 480         retval = comedi_pci_enable(dev);
 481         if (retval)
 482                 return retval;
 483         pci_set_master(pcidev);
 484
 485         devpriv->plx9080_iobase = pci_ioremap_bar(pcidev, 0);
 486         devpriv->hpdi_iobase = pci_ioremap_bar(pcidev, 2);
 487         if (!devpriv->plx9080_iobase || !devpriv->hpdi_iobase) {
 488                 dev_warn(dev->class_dev, "failed to remap io memory\n");
 489                 return -ENOMEM;
 490         }
 491
 492         DEBUG_PRINT(" plx9080 remapped to 0x%p\n", devpriv->plx9080_iobase);
 493         DEBUG_PRINT(" hpdi remapped to 0x%p\n", devpriv->hpdi_iobase);
 494
 495         init_plx9080(dev);
 496
 497         /*  get irq */
 498         if (request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED,
 499                         dev->board_name, dev)) {
 500                 dev_warn(dev->class_dev,
 501                          "unable to allocate irq %u\n", pcidev->irq);
 502                 return -EINVAL;
 503         }
 504         dev->irq = pcidev->irq;
 505
 506         dev_dbg(dev->class_dev, " irq %u\n", dev->irq);
 507
 508         /*  allocate pci dma buffers */
 509         for (i = 0; i < NUM_DMA_BUFFERS; i++) {
 510                 devpriv->dio_buffer[i] =
 511                     pci_alloc_consistent(pcidev, DMA_BUFFER_SIZE,
 512                                          &devpriv->dio_buffer_phys_addr[i]);
 513                 DEBUG_PRINT("dio_buffer at virt 0x%p, phys 0x%lx\n",
 514                             devpriv->dio_buffer[i],
 515                             (unsigned long)devpriv->dio_buffer_phys_addr[i]);
 516         }
 517         /*  allocate dma descriptors */
 518         devpriv->dma_desc = pci_alloc_consistent(pcidev,
 519                                                  sizeof(struct plx_dma_desc) *
 520                                                  NUM_DMA_DESCRIPTORS,
 521                                                  &devpriv->dma_desc_phys_addr);
 522         if (devpriv->dma_desc_phys_addr & 0xf) {
 523                 dev_warn(dev->class_dev,
 524                          " dma descriptors not quad-word aligned (bug)\n");
 525                 return -EIO;
 526         }
 527
 528         retval = setup_dma_descriptors(dev, 0x1000);
 529         if (retval < 0)
 530                 return retval;
 531
 532         retval = setup_subdevices(dev);
 533         if (retval < 0)
 534                 return retval;
 535
 536         return init_hpdi(dev);
 537 }
 538
 539 static void hpdi_detach(struct comedi_device *dev)
 540 {
 541         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
 542         struct hpdi_private *devpriv = dev->private;
 543         unsigned int i;
 544
 545         if (dev->irq)
 546                 free_irq(dev->irq, dev);
 547         if (devpriv) {
 548                 if (devpriv->plx9080_iobase) {
 549                         disable_plx_interrupts(dev);
 550                         iounmap(devpriv->plx9080_iobase);
 551                 }
 552                 if (devpriv->hpdi_iobase)
 553                         iounmap(devpriv->hpdi_iobase);
 554                 /*  free pci dma buffers */
 555                 for (i = 0; i < NUM_DMA_BUFFERS; i++) {
 556                         if (devpriv->dio_buffer[i])
 557                                 pci_free_consistent(pcidev,
 558                                                     DMA_BUFFER_SIZE,
 559                                                     devpriv->dio_buffer[i],
 560                                                     devpriv->
 561                                                     dio_buffer_phys_addr[i]);
 562                 }
 563                 /*  free dma descriptors */
 564                 if (devpriv->dma_desc)
 565                         pci_free_consistent(pcidev,
 566                                             sizeof(struct plx_dma_desc) *
 567                                             NUM_DMA_DESCRIPTORS,
 568                                             devpriv->dma_desc,
 569                                             devpriv->dma_desc_phys_addr);
 570         }
 571         comedi_pci_disable(dev);
 572 }
 573
 574 static int dio_config_block_size(struct comedi_device *dev, unsigned int *data)
 575 {
 576         unsigned int requested_block_size;
 577         int retval;
 578
 579         requested_block_size = data[1];
 580
 581         retval = setup_dma_descriptors(dev, requested_block_size);
 582         if (retval < 0)
 583                 return retval;
 584
 585         data[1] = retval;
 586
 587         return 2;
 588 }
 589
 590 static int di_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
 591                        struct comedi_cmd *cmd)
 592 {
 593         int err = 0;
 594         int i;
 595
 596         /* Step 1 : check if triggers are trivially valid */
 597
 598         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 599         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
 600         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 601         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 602         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 603
 604         if (err)
 605                 return 1;
 606
 607         /* Step 2a : make sure trigger sources are unique */
 608
 609         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 610
 611         /* Step 2b : and mutually compatible */
 612
 613         if (err)
 614                 return 2;
 615
 616         /* Step 3: check if arguments are trivially valid */
 617
 618         if (!cmd->chanlist_len) {
 619                 cmd->chanlist_len = 32;
 620                 err |= -EINVAL;
 621         }
 622         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 623
 624         switch (cmd->stop_src) {
 625         case TRIG_COUNT:
 626                 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
 627                 break;
 628         case TRIG_NONE:
 629                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 630                 break;
 631         default:
 632                 break;
 633         }
 634
 635         if (err)
 636                 return 3;
 637
 638         /* step 4: fix up any arguments */
 639
 640         if (err)
 641                 return 4;
 642
 643         if (!cmd->chanlist)
 644                 return 0;
 645
 646         for (i = 1; i < cmd->chanlist_len; i++) {
 647                 if (CR_CHAN(cmd->chanlist[i]) != i) {
 648                         /*  XXX could support 8 or 16 channels */
 649                         comedi_error(dev,
 650                                      "chanlist must be ch 0 to 31 in order");
 651                         err++;
 652                         break;
 653                 }
 654         }
 655
 656         if (err)
 657                 return 5;
 658
 659         return 0;
 660 }
 661
 662 static int hpdi_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
 663                          struct comedi_cmd *cmd)
 664 {
 665         if (s->io_bits)
 666                 return -EINVAL;
 667         else
 668                 return di_cmd_test(dev, s, cmd);
 669 }
 670
 671 static inline void hpdi_writel(struct comedi_device *dev, uint32_t bits,
 672                                unsigned int offset)
 673 {
 674         struct hpdi_private *devpriv = dev->private;
 675
 676         writel(bits | devpriv->bits[offset / sizeof(uint32_t)],
 677                devpriv->hpdi_iobase + offset);
 678 }
 679
 680 static int di_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 681 {
 682         struct hpdi_private *devpriv = dev->private;
 683         uint32_t bits;
 684         unsigned long flags;
 685         struct comedi_async *async = s->async;
 686         struct comedi_cmd *cmd = &async->cmd;
 687
 688         hpdi_writel(dev, RX_FIFO_RESET_BIT, BOARD_CONTROL_REG);
 689
 690         DEBUG_PRINT("hpdi: in di_cmd\n");
 691
 692         abort_dma(dev, 0);
 693
 694         devpriv->dma_desc_index = 0;
 695
 696         /* These register are supposedly unused during chained dma,
 697          * but I have found that left over values from last operation
 698          * occasionally cause problems with transfer of first dma
 699          * block.  Initializing them to zero seems to fix the problem. */
 700         writel(0, devpriv->plx9080_iobase + PLX_DMA0_TRANSFER_SIZE_REG);
 701         writel(0, devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG);
 702         writel(0, devpriv->plx9080_iobase + PLX_DMA0_LOCAL_ADDRESS_REG);
 703         /*  give location of first dma descriptor */
 704         bits =
 705             devpriv->dma_desc_phys_addr | PLX_DESC_IN_PCI_BIT |
 706             PLX_INTR_TERM_COUNT | PLX_XFER_LOCAL_TO_PCI;
 707         writel(bits, devpriv->plx9080_iobase + PLX_DMA0_DESCRIPTOR_REG);
 708
 709         /*  spinlock for plx dma control/status reg */
 710         spin_lock_irqsave(&dev->spinlock, flags);
 711         /*  enable dma transfer */
 712         writeb(PLX_DMA_EN_BIT | PLX_DMA_START_BIT | PLX_CLEAR_DMA_INTR_BIT,
 713                devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
 714         spin_unlock_irqrestore(&dev->spinlock, flags);
 715
 716         if (cmd->stop_src == TRIG_COUNT)
 717                 devpriv->dio_count = cmd->stop_arg;
 718         else
 719                 devpriv->dio_count = 1;
 720
 721         /*  clear over/under run status flags */
 722         writel(RX_UNDERRUN_BIT | RX_OVERRUN_BIT,
 723                devpriv->hpdi_iobase + BOARD_STATUS_REG);
 724         /*  enable interrupts */
 725         writel(intr_bit(RX_FULL_INTR),
 726                devpriv->hpdi_iobase + INTERRUPT_CONTROL_REG);
 727
 728         DEBUG_PRINT("hpdi: starting rx\n");
 729         hpdi_writel(dev, RX_ENABLE_BIT, BOARD_CONTROL_REG);
 730
 731         return 0;
 732 }
 733
 734 static int hpdi_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 735 {
 736         if (s->io_bits)
 737                 return -EINVAL;
 738         else
 739                 return di_cmd(dev, s);
 740 }
 741
 742 static void drain_dma_buffers(struct comedi_device *dev, unsigned int channel)
 743 {
 744         struct hpdi_private *devpriv = dev->private;
 745         struct comedi_async *async = dev->read_subdev->async;
 746         uint32_t next_transfer_addr;
 747         int j;
 748         int num_samples = 0;
 749         void __iomem *pci_addr_reg;
 750
 751         if (channel)
 752                 pci_addr_reg =
 753                     devpriv->plx9080_iobase + PLX_DMA1_PCI_ADDRESS_REG;
 754         else
 755                 pci_addr_reg =
 756                     devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG;
 757
 758         /*  loop until we have read all the full buffers */
 759         j = 0;
 760         for (next_transfer_addr = readl(pci_addr_reg);
 761              (next_transfer_addr <
 762               le32_to_cpu(devpriv->dma_desc[devpriv->dma_desc_index].
 763                           pci_start_addr)
 764               || next_transfer_addr >=
 765               le32_to_cpu(devpriv->dma_desc[devpriv->dma_desc_index].
 766                           pci_start_addr) + devpriv->block_size)
 767              && j < devpriv->num_dma_descriptors; j++) {
 768                 /*  transfer data from dma buffer to comedi buffer */
 769                 num_samples = devpriv->block_size / sizeof(uint32_t);
 770                 if (async->cmd.stop_src == TRIG_COUNT) {
 771                         if (num_samples > devpriv->dio_count)
 772                                 num_samples = devpriv->dio_count;
 773                         devpriv->dio_count -= num_samples;
 774                 }
 775                 cfc_write_array_to_buffer(dev->read_subdev,
 776                                           devpriv->desc_dio_buffer[devpriv->
 777                                                                      dma_desc_index],
 778                                           num_samples * sizeof(uint32_t));
 779                 devpriv->dma_desc_index++;
 780                 devpriv->dma_desc_index %= devpriv->num_dma_descriptors;
 781
 782                 DEBUG_PRINT("next desc addr 0x%lx\n", (unsigned long)
 783                             devpriv->dma_desc[devpriv->dma_desc_index].
 784                             next);
 785                 DEBUG_PRINT("pci addr reg 0x%x\n", next_transfer_addr);
 786         }
 787         /*  XXX check for buffer overrun somehow */
 788 }
 789
 790 static irqreturn_t handle_interrupt(int irq, void *d)
 791 {
 792         struct comedi_device *dev = d;
 793         struct hpdi_private *devpriv = dev->private;
 794         struct comedi_subdevice *s = dev->read_subdev;
 795         struct comedi_async *async = s->async;
 796         uint32_t hpdi_intr_status, hpdi_board_status;
 797         uint32_t plx_status;
 798         uint32_t plx_bits;
 799         uint8_t dma0_status, dma1_status;
 800         unsigned long flags;
 801
 802         if (!dev->attached)
 803                 return IRQ_NONE;
 804
 805         plx_status = readl(devpriv->plx9080_iobase + PLX_INTRCS_REG);
 806         if ((plx_status & (ICS_DMA0_A | ICS_DMA1_A | ICS_LIA)) == 0)
 807                 return IRQ_NONE;
 808
 809         hpdi_intr_status = readl(devpriv->hpdi_iobase + INTERRUPT_STATUS_REG);
 810         hpdi_board_status = readl(devpriv->hpdi_iobase + BOARD_STATUS_REG);
 811
 812         async->events = 0;
 813
 814         if (hpdi_intr_status) {
 815                 DEBUG_PRINT("hpdi: intr status 0x%x, ", hpdi_intr_status);
 816                 writel(hpdi_intr_status,
 817                        devpriv->hpdi_iobase + INTERRUPT_STATUS_REG);
 818         }
 819         /*  spin lock makes sure no one else changes plx dma control reg */
 820         spin_lock_irqsave(&dev->spinlock, flags);
 821         dma0_status = readb(devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
 822         if (plx_status & ICS_DMA0_A) {  /*  dma chan 0 interrupt */
 823                 writeb((dma0_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT,
 824                        devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
 825
 826                 DEBUG_PRINT("dma0 status 0x%x\n", dma0_status);
 827                 if (dma0_status & PLX_DMA_EN_BIT)
 828                         drain_dma_buffers(dev, 0);
 829                 DEBUG_PRINT(" cleared dma ch0 interrupt\n");
 830         }
 831         spin_unlock_irqrestore(&dev->spinlock, flags);
 832
 833         /*  spin lock makes sure no one else changes plx dma control reg */
 834         spin_lock_irqsave(&dev->spinlock, flags);
 835         dma1_status = readb(devpriv->plx9080_iobase + PLX_DMA1_CS_REG);
 836         if (plx_status & ICS_DMA1_A) {  /*  XXX *//*  dma chan 1 interrupt */
 837                 writeb((dma1_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT,
 838                        devpriv->plx9080_iobase + PLX_DMA1_CS_REG);
 839                 DEBUG_PRINT("dma1 status 0x%x\n", dma1_status);
 840
 841                 DEBUG_PRINT(" cleared dma ch1 interrupt\n");
 842         }
 843         spin_unlock_irqrestore(&dev->spinlock, flags);
 844
 845         /*  clear possible plx9080 interrupt sources */
 846         if (plx_status & ICS_LDIA) {    /*  clear local doorbell interrupt */
 847                 plx_bits = readl(devpriv->plx9080_iobase + PLX_DBR_OUT_REG);
 848                 writel(plx_bits, devpriv->plx9080_iobase + PLX_DBR_OUT_REG);
 849                 DEBUG_PRINT(" cleared local doorbell bits 0x%x\n", plx_bits);
 850         }
 851
 852         if (hpdi_board_status & RX_OVERRUN_BIT) {
 853                 comedi_error(dev, "rx fifo overrun");
 854                 async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 855                 DEBUG_PRINT("dma0_status 0x%x\n",
 856                             (int)readb(devpriv->plx9080_iobase +
 857                                        PLX_DMA0_CS_REG));
 858         }
 859
 860         if (hpdi_board_status & RX_UNDERRUN_BIT) {
 861                 comedi_error(dev, "rx fifo underrun");
 862                 async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 863         }
 864
 865         if (devpriv->dio_count == 0)
 866                 async->events |= COMEDI_CB_EOA;
 867
 868         DEBUG_PRINT("board status 0x%x, ", hpdi_board_status);
 869         DEBUG_PRINT("plx status 0x%x\n", plx_status);
 870         if (async->events)
 871                 DEBUG_PRINT(" events 0x%x\n", async->events);
 872
 873         cfc_handle_events(dev, s);
 874
 875         return IRQ_HANDLED;
 876 }
 877
 878 static void abort_dma(struct comedi_device *dev, unsigned int channel)
 879 {
 880         struct hpdi_private *devpriv = dev->private;
 881         unsigned long flags;
 882
 883         /*  spinlock for plx dma control/status reg */
 884         spin_lock_irqsave(&dev->spinlock, flags);
 885
 886         plx9080_abort_dma(devpriv->plx9080_iobase, channel);
 887
 888         spin_unlock_irqrestore(&dev->spinlock, flags);
 889 }
 890
 891 static int hpdi_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
 892 {
 893         struct hpdi_private *devpriv = dev->private;
 894
 895         hpdi_writel(dev, 0, BOARD_CONTROL_REG);
 896
 897         writel(0, devpriv->hpdi_iobase + INTERRUPT_CONTROL_REG);
 898
 899         abort_dma(dev, 0);
 900
 901         return 0;
 902 }
 903
 904 static struct comedi_driver gsc_hpdi_driver = {
 905         .driver_name    = "gsc_hpdi",
 906         .module         = THIS_MODULE,
 907         .auto_attach    = hpdi_auto_attach,
 908         .detach         = hpdi_detach,
 909 };
 910
 911 static int gsc_hpdi_pci_probe(struct pci_dev *dev,
 912                               const struct pci_device_id *id)
 913 {
 914         return comedi_pci_auto_config(dev, &gsc_hpdi_driver, id->driver_data);
 915 }
 916
 917 static DEFINE_PCI_DEVICE_TABLE(gsc_hpdi_pci_table) = {
 918         { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9080, PCI_VENDOR_ID_PLX,
 919                     0x2400, 0, 0, 0},
 920         { 0 }
 921 };
 922 MODULE_DEVICE_TABLE(pci, gsc_hpdi_pci_table);
 923
 924 static struct pci_driver gsc_hpdi_pci_driver = {
 925         .name           = "gsc_hpdi",
 926         .id_table       = gsc_hpdi_pci_table,
 927         .probe          = gsc_hpdi_pci_probe,
 928         .remove         = comedi_pci_auto_unconfig,
 929 };
 930 module_comedi_pci_driver(gsc_hpdi_driver, gsc_hpdi_pci_driver);
 931
 932 MODULE_AUTHOR("Comedi http://www.comedi.org");
 933 MODULE_DESCRIPTION("Comedi low-level driver");
 934 MODULE_LICENSE("GPL");