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