drivers/staging/comedi/drivers/rtd520.c

   1 /*
   2     comedi/drivers/rtd520.c
   3     Comedi driver for Real Time Devices (RTD) PCI4520/DM7520
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 2001 David A. Schleef <ds@schleef.org>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22 /*
  23 Driver: rtd520
  24 Description: Real Time Devices PCI4520/DM7520
  25 Author: Dan Christian
  26 Devices: [Real Time Devices] DM7520HR-1 (rtd520), DM7520HR-8,
  27   PCI4520, PCI4520-8
  28 Status: Works.  Only tested on DM7520-8.  Not SMP safe.
  29
  30 Configuration options:
  31   [0] - PCI bus of device (optional)
  32           If bus/slot is not specified, the first available PCI
  33           device will be used.
  34   [1] - PCI slot of device (optional)
  35 */
  36 /*
  37     Created by Dan Christian, NASA Ames Research Center.
  38
  39     The PCI4520 is a PCI card.  The DM7520 is a PC/104-plus card.
  40     Both have:
  41     8/16 12 bit ADC with FIFO and channel gain table
  42     8 bits high speed digital out (for external MUX) (or 8 in or 8 out)
  43     8 bits high speed digital in with FIFO and interrupt on change (or 8 IO)
  44     2 12 bit DACs with FIFOs
  45     2 bits output
  46     2 bits input
  47     bus mastering DMA
  48     timers: ADC sample, pacer, burst, about, delay, DA1, DA2
  49     sample counter
  50     3 user timer/counters (8254)
  51     external interrupt
  52
  53     The DM7520 has slightly fewer features (fewer gain steps).
  54
  55     These boards can support external multiplexors and multi-board
  56     synchronization, but this driver doesn't support that.
  57
  58     Board docs: http://www.rtdusa.com/PC104/DM/analog%20IO/dm7520.htm
  59     Data sheet: http://www.rtdusa.com/pdf/dm7520.pdf
  60     Example source: http://www.rtdusa.com/examples/dm/dm7520.zip
  61     Call them and ask for the register level manual.
  62     PCI chip: http://www.plxtech.com/products/toolbox/9080.htm
  63
  64     Notes:
  65     This board is memory mapped.  There is some IO stuff, but it isn't needed.
  66
  67     I use a pretty loose naming style within the driver (rtd_blah).
  68     All externally visible names should be rtd520_blah.
  69     I use camelCase for structures (and inside them).
  70     I may also use upper CamelCase for function names (old habit).
  71
  72     This board is somewhat related to the RTD PCI4400 board.
  73
  74     I borrowed heavily from the ni_mio_common, ni_atmio16d, mite, and
  75     das1800, since they have the best documented code.  Driver
  76     cb_pcidas64.c uses the same DMA controller.
  77
  78     As far as I can tell, the About interrupt doesnt work if Sample is
  79     also enabled.  It turns out that About really isn't needed, since
  80     we always count down samples read.
  81
  82     There was some timer/counter code, but it didn't follow the right API.
  83
  84 */
  85
  86 /*
  87   driver status:
  88
  89   Analog-In supports instruction and command mode.
  90
  91   With DMA, you can sample at 1.15Mhz with 70% idle on a 400Mhz K6-2
  92   (single channel, 64K read buffer).  I get random system lockups when
  93   using DMA with ALI-15xx based systems.  I haven't been able to test
  94   any other chipsets.  The lockups happen soon after the start of an
  95   acquistion, not in the middle of a long run.
  96
  97   Without DMA, you can do 620Khz sampling with 20% idle on a 400Mhz K6-2
  98   (with a 256K read buffer).
  99
 100   Digital-IO and Analog-Out only support instruction mode.
 101
 102 */
 103
 104 #include <linux/delay.h>
 105
 106 #include "../comedidev.h"
 107 #include "comedi_pci.h"
 108
 109 #define DRV_NAME "rtd520"
 110
 111 /*======================================================================
 112   Driver specific stuff (tunable)
 113 ======================================================================*/
 114 /* Enable this to test the new DMA support. You may get hard lock ups */
 115 /*#define USE_DMA*/
 116
 117 /* We really only need 2 buffers.  More than that means being much
 118    smarter about knowing which ones are full. */
 119 #define DMA_CHAIN_COUNT 2       /* max DMA segments/buffers in a ring (min 2) */
 120
 121 /* Target period for periodic transfers.  This sets the user read latency. */
 122 /* Note: There are certain rates where we give this up and transfer 1/2 FIFO */
 123 /* If this is too low, efficiency is poor */
 124 #define TRANS_TARGET_PERIOD 10000000    /* 10 ms (in nanoseconds) */
 125
 126 /* Set a practical limit on how long a list to support (affects memory use) */
 127 /* The board support a channel list up to the FIFO length (1K or 8K) */
 128 #define RTD_MAX_CHANLIST        128     /* max channel list that we allow */
 129
 130 /* tuning for ai/ao instruction done polling */
 131 #ifdef FAST_SPIN
 132 #define WAIT_QUIETLY            /* as nothing, spin on done bit */
 133 #define RTD_ADC_TIMEOUT 66000   /* 2 msec at 33mhz bus rate */
 134 #define RTD_DAC_TIMEOUT 66000
 135 #define RTD_DMA_TIMEOUT 33000   /* 1 msec */
 136 #else
 137 /* by delaying, power and electrical noise are reduced somewhat */
 138 #define WAIT_QUIETLY    comedi_udelay (1)
 139 #define RTD_ADC_TIMEOUT 2000    /* in usec */
 140 #define RTD_DAC_TIMEOUT 2000    /* in usec */
 141 #define RTD_DMA_TIMEOUT 1000    /* in usec */
 142 #endif
 143
 144 /*======================================================================
 145   Board specific stuff
 146 ======================================================================*/
 147
 148 /* registers  */
 149 #define PCI_VENDOR_ID_RTD       0x1435
 150 /*
 151   The board has three memory windows: las0, las1, and lcfg (the PCI chip)
 152   Las1 has the data and can be burst DMAed 32bits at a time.
 153 */
 154 #define LCFG_PCIINDEX   0
 155 /* PCI region 1 is a 256 byte IO space mapping.  Use??? */
 156 #define LAS0_PCIINDEX   2       /* PCI memory resources */
 157 #define LAS1_PCIINDEX   3
 158 #define LCFG_PCISIZE    0x100
 159 #define LAS0_PCISIZE    0x200
 160 #define LAS1_PCISIZE    0x10
 161
 162 #define RTD_CLOCK_RATE  8000000 /* 8Mhz onboard clock */
 163 #define RTD_CLOCK_BASE  125     /* clock period in ns */
 164
 165 /* Note: these speed are slower than the spec, but fit the counter resolution*/
 166 #define RTD_MAX_SPEED   1625    /* when sampling, in nanoseconds */
 167 /* max speed if we don't have to wait for settling */
 168 #define RTD_MAX_SPEED_1 875     /* if single channel, in nanoseconds */
 169
 170 #define RTD_MIN_SPEED   2097151875      /* (24bit counter) in nanoseconds */
 171 /* min speed when only 1 channel (no burst counter) */
 172 #define RTD_MIN_SPEED_1 5000000 /* 200Hz, in nanoseconds */
 173
 174 #include "rtd520.h"
 175 #include "plx9080.h"
 176
 177 /* Setup continuous ring of 1/2 FIFO transfers.  See RTD manual p91 */
 178 #define DMA_MODE_BITS (\
 179                        PLX_LOCAL_BUS_16_WIDE_BITS \
 180                        | PLX_DMA_EN_READYIN_BIT \
 181                        | PLX_DMA_LOCAL_BURST_EN_BIT \
 182                        | PLX_EN_CHAIN_BIT \
 183                        | PLX_DMA_INTR_PCI_BIT \
 184                        | PLX_LOCAL_ADDR_CONST_BIT \
 185                        | PLX_DEMAND_MODE_BIT)
 186
 187 #define DMA_TRANSFER_BITS (\
 188 /* descriptors in PCI memory*/  PLX_DESC_IN_PCI_BIT \
 189 /* interrupt at end of block */ | PLX_INTR_TERM_COUNT \
 190 /* from board to PCI */         | PLX_XFER_LOCAL_TO_PCI)
 191
 192 /*======================================================================
 193   Comedi specific stuff
 194 ======================================================================*/
 195
 196 /*
 197   The board has 3 input modes and the gains of 1,2,4,...32 (, 64, 128)
 198 */
 199 static const struct comedi_lrange rtd_ai_7520_range = { 18, {
 200                         /* +-5V input range gain steps */
 201                         BIP_RANGE(5.0),
 202                         BIP_RANGE(5.0 / 2),
 203                         BIP_RANGE(5.0 / 4),
 204                         BIP_RANGE(5.0 / 8),
 205                         BIP_RANGE(5.0 / 16),
 206                         BIP_RANGE(5.0 / 32),
 207                         /* +-10V input range gain steps */
 208                         BIP_RANGE(10.0),
 209                         BIP_RANGE(10.0 / 2),
 210                         BIP_RANGE(10.0 / 4),
 211                         BIP_RANGE(10.0 / 8),
 212                         BIP_RANGE(10.0 / 16),
 213                         BIP_RANGE(10.0 / 32),
 214                         /* +10V input range gain steps */
 215                         UNI_RANGE(10.0),
 216                         UNI_RANGE(10.0 / 2),
 217                         UNI_RANGE(10.0 / 4),
 218                         UNI_RANGE(10.0 / 8),
 219                         UNI_RANGE(10.0 / 16),
 220                         UNI_RANGE(10.0 / 32),
 221
 222         }
 223 };
 224
 225 /* PCI4520 has two more gains (6 more entries) */
 226 static const struct comedi_lrange rtd_ai_4520_range = { 24, {
 227                         /* +-5V input range gain steps */
 228                         BIP_RANGE(5.0),
 229                         BIP_RANGE(5.0 / 2),
 230                         BIP_RANGE(5.0 / 4),
 231                         BIP_RANGE(5.0 / 8),
 232                         BIP_RANGE(5.0 / 16),
 233                         BIP_RANGE(5.0 / 32),
 234                         BIP_RANGE(5.0 / 64),
 235                         BIP_RANGE(5.0 / 128),
 236                         /* +-10V input range gain steps */
 237                         BIP_RANGE(10.0),
 238                         BIP_RANGE(10.0 / 2),
 239                         BIP_RANGE(10.0 / 4),
 240                         BIP_RANGE(10.0 / 8),
 241                         BIP_RANGE(10.0 / 16),
 242                         BIP_RANGE(10.0 / 32),
 243                         BIP_RANGE(10.0 / 64),
 244                         BIP_RANGE(10.0 / 128),
 245                         /* +10V input range gain steps */
 246                         UNI_RANGE(10.0),
 247                         UNI_RANGE(10.0 / 2),
 248                         UNI_RANGE(10.0 / 4),
 249                         UNI_RANGE(10.0 / 8),
 250                         UNI_RANGE(10.0 / 16),
 251                         UNI_RANGE(10.0 / 32),
 252                         UNI_RANGE(10.0 / 64),
 253                         UNI_RANGE(10.0 / 128),
 254         }
 255 };
 256
 257 /* Table order matches range values */
 258 static const struct comedi_lrange rtd_ao_range = { 4, {
 259                         RANGE(0, 5),
 260                         RANGE(0, 10),
 261                         RANGE(-5, 5),
 262                         RANGE(-10, 10),
 263         }
 264 };
 265
 266 /*
 267   Board descriptions
 268  */
 269 struct rtdBoard {
 270         const char *name;       /* must be first */
 271         int device_id;
 272         int aiChans;
 273         int aiBits;
 274         int aiMaxGain;
 275         int range10Start;       /* start of +-10V range */
 276         int rangeUniStart;      /* start of +10V range */
 277 };
 278
 279 static const struct rtdBoard rtd520Boards[] = {
 280         {
 281         .name = "DM7520",
 282         .device_id = 0x7520,
 283         .aiChans = 16,
 284         .aiBits = 12,
 285         .aiMaxGain = 32,
 286         .range10Start = 6,
 287         .rangeUniStart = 12,
 288                 },
 289         {
 290         .name = "PCI4520",
 291         .device_id = 0x4520,
 292         .aiChans = 16,
 293         .aiBits = 12,
 294         .aiMaxGain = 128,
 295         .range10Start = 8,
 296         .rangeUniStart = 16,
 297                 },
 298 };
 299
 300 static DEFINE_PCI_DEVICE_TABLE(rtd520_pci_table) = {
 301         {PCI_VENDOR_ID_RTD, 0x7520, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 302         {PCI_VENDOR_ID_RTD, 0x4520, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 303         {0}
 304 };
 305
 306 MODULE_DEVICE_TABLE(pci, rtd520_pci_table);
 307
 308 /*
 309  * Useful for shorthand access to the particular board structure
 310  */
 311 #define thisboard ((const struct rtdBoard *)dev->board_ptr)
 312
 313 /*
 314    This structure is for data unique to this hardware driver.
 315    This is also unique for each board in the system.
 316 */
 317 struct rtdPrivate {
 318         /* memory mapped board structures */
 319         void *las0;
 320         void *las1;
 321         void *lcfg;
 322
 323         unsigned long intCount; /* interrupt count */
 324         long aiCount;           /* total transfer size (samples) */
 325         int transCount;         /* # to tranfer data. 0->1/2FIFO */
 326         int flags;              /* flag event modes */
 327
 328         /* PCI device info */
 329         struct pci_dev *pci_dev;
 330         int got_regions;        /* non-zero if PCI regions owned */
 331
 332         /* channel list info */
 333         /* chanBipolar tracks whether a channel is bipolar (and needs +2048) */
 334         unsigned char chanBipolar[RTD_MAX_CHANLIST / 8];        /* bit array */
 335
 336         /* read back data */
 337         unsigned int aoValue[2];        /* Used for AO read back */
 338
 339         /* timer gate (when enabled) */
 340         u8 utcGate[4];          /* 1 extra allows simple range check */
 341
 342         /* shadow registers affect other registers, but cant be read back */
 343         /* The macros below update these on writes */
 344         u16 intMask;            /* interrupt mask */
 345         u16 intClearMask;       /* interrupt clear mask */
 346         u8 utcCtrl[4];          /* crtl mode for 3 utc + read back */
 347         u8 dioStatus;           /* could be read back (dio0Ctrl) */
 348 #ifdef USE_DMA
 349         /* Always DMA 1/2 FIFO.  Buffer (dmaBuff?) is (at least) twice that size.
 350            After transferring, interrupt processes 1/2 FIFO and passes to comedi */
 351         s16 dma0Offset;         /* current processing offset (0, 1/2) */
 352         uint16_t *dma0Buff[DMA_CHAIN_COUNT];    /* DMA buffers (for ADC) */
 353         dma_addr_t dma0BuffPhysAddr[DMA_CHAIN_COUNT];   /* physical addresses */
 354         struct plx_dma_desc *dma0Chain; /* DMA descriptor ring for dmaBuff */
 355         dma_addr_t dma0ChainPhysAddr;   /* physical addresses */
 356         /* shadow registers */
 357         u8 dma0Control;
 358         u8 dma1Control;
 359 #endif                          /* USE_DMA */
 360         unsigned fifoLen;
 361 };
 362
 363 /* bit defines for "flags" */
 364 #define SEND_EOS        0x01    /* send End Of Scan events */
 365 #define DMA0_ACTIVE     0x02    /* DMA0 is active */
 366 #define DMA1_ACTIVE     0x04    /* DMA1 is active */
 367
 368 /* Macros for accessing channel list bit array */
 369 #define CHAN_ARRAY_TEST(array, index) \
 370         (((array)[(index)/8] >> ((index) & 0x7)) & 0x1)
 371 #define CHAN_ARRAY_SET(array, index) \
 372         (((array)[(index)/8] |= 1 << ((index) & 0x7)))
 373 #define CHAN_ARRAY_CLEAR(array, index) \
 374         (((array)[(index)/8] &= ~(1 << ((index) & 0x7))))
 375
 376 /*
 377  * most drivers define the following macro to make it easy to
 378  * access the private structure.
 379  */
 380 #define devpriv ((struct rtdPrivate *)dev->private)
 381
 382 /* Macros to access registers */
 383
 384 /* Reset board */
 385 #define RtdResetBoard(dev) \
 386     writel (0, devpriv->las0+LAS0_BOARD_RESET)
 387
 388 /* Reset channel gain table read pointer */
 389 #define RtdResetCGT(dev) \
 390     writel (0, devpriv->las0+LAS0_CGT_RESET)
 391
 392 /* Reset channel gain table read and write pointers */
 393 #define RtdClearCGT(dev) \
 394     writel (0, devpriv->las0+LAS0_CGT_CLEAR)
 395
 396 /* Reset channel gain table read and write pointers */
 397 #define RtdEnableCGT(dev, v) \
 398     writel ((v > 0) ? 1 : 0, devpriv->las0+LAS0_CGT_ENABLE)
 399
 400 /* Write channel gain table entry */
 401 #define RtdWriteCGTable(dev, v) \
 402     writel (v, devpriv->las0+LAS0_CGT_WRITE)
 403
 404 /* Write Channel Gain Latch */
 405 #define RtdWriteCGLatch(dev, v) \
 406     writel (v, devpriv->las0+LAS0_CGL_WRITE)
 407
 408 /* Reset ADC FIFO */
 409 #define RtdAdcClearFifo(dev) \
 410     writel (0, devpriv->las0+LAS0_ADC_FIFO_CLEAR)
 411
 412 /* Set ADC start conversion source select (write only) */
 413 #define RtdAdcConversionSource(dev, v) \
 414     writel (v, devpriv->las0+LAS0_ADC_CONVERSION)
 415
 416 /* Set burst start source select (write only) */
 417 #define RtdBurstStartSource(dev, v) \
 418     writel (v, devpriv->las0+LAS0_BURST_START)
 419
 420 /* Set Pacer start source select (write only) */
 421 #define RtdPacerStartSource(dev, v) \
 422     writel (v, devpriv->las0+LAS0_PACER_START)
 423
 424 /* Set Pacer stop source select (write only) */
 425 #define RtdPacerStopSource(dev, v) \
 426     writel (v, devpriv->las0+LAS0_PACER_STOP)
 427
 428 /* Set Pacer clock source select (write only) 0=external 1=internal */
 429 #define RtdPacerClockSource(dev, v) \
 430     writel ((v > 0) ? 1 : 0, devpriv->las0+LAS0_PACER_SELECT)
 431
 432 /* Set sample counter source select (write only) */
 433 #define RtdAdcSampleCounterSource(dev, v) \
 434     writel (v, devpriv->las0+LAS0_ADC_SCNT_SRC)
 435
 436 /* Set Pacer trigger mode select (write only) 0=single cycle, 1=repeat */
 437 #define RtdPacerTriggerMode(dev, v) \
 438     writel ((v > 0) ? 1 : 0, devpriv->las0+LAS0_PACER_REPEAT)
 439
 440 /* Set About counter stop enable (write only) */
 441 #define RtdAboutStopEnable(dev, v) \
 442     writel ((v > 0) ? 1 : 0, devpriv->las0+LAS0_ACNT_STOP_ENABLE)
 443
 444 /* Set external trigger polarity (write only) 0=positive edge, 1=negative */
 445 #define RtdTriggerPolarity(dev, v) \
 446     writel ((v > 0) ? 1 : 0, devpriv->las0+LAS0_ETRG_POLARITY)
 447
 448 /* Start single ADC conversion */
 449 #define RtdAdcStart(dev) \
 450     writew (0, devpriv->las0+LAS0_ADC)
 451
 452 /* Read one ADC data value (12bit (with sign extend) as 16bit) */
 453 /* Note: matches what DMA would get.  Actual value >> 3 */
 454 #define RtdAdcFifoGet(dev) \
 455     readw (devpriv->las1+LAS1_ADC_FIFO)
 456
 457 /* Read two ADC data values (DOESNT WORK) */
 458 #define RtdAdcFifoGet2(dev) \
 459     readl (devpriv->las1+LAS1_ADC_FIFO)
 460
 461 /* FIFO status */
 462 #define RtdFifoStatus(dev) \
 463     readl (devpriv->las0+LAS0_ADC)
 464
 465 /* pacer start/stop read=start, write=stop*/
 466 #define RtdPacerStart(dev) \
 467     readl (devpriv->las0+LAS0_PACER)
 468 #define RtdPacerStop(dev) \
 469     writel (0, devpriv->las0+LAS0_PACER)
 470
 471 /* Interrupt status */
 472 #define RtdInterruptStatus(dev) \
 473     readw (devpriv->las0+LAS0_IT)
 474
 475 /* Interrupt mask */
 476 #define RtdInterruptMask(dev, v) \
 477     writew ((devpriv->intMask = (v)), devpriv->las0+LAS0_IT)
 478
 479 /* Interrupt status clear (only bits set in mask) */
 480 #define RtdInterruptClear(dev) \
 481     readw (devpriv->las0+LAS0_CLEAR)
 482
 483 /* Interrupt clear mask */
 484 #define RtdInterruptClearMask(dev, v) \
 485     writew ((devpriv->intClearMask = (v)), devpriv->las0+LAS0_CLEAR)
 486
 487 /* Interrupt overrun status */
 488 #define RtdInterruptOverrunStatus(dev) \
 489     readl (devpriv->las0+LAS0_OVERRUN)
 490
 491 /* Interrupt overrun clear */
 492 #define RtdInterruptOverrunClear(dev) \
 493     writel (0, devpriv->las0+LAS0_OVERRUN)
 494
 495 /* Pacer counter, 24bit */
 496 #define RtdPacerCount(dev) \
 497     readl (devpriv->las0+LAS0_PCLK)
 498 #define RtdPacerCounter(dev, v) \
 499     writel ((v) & 0xffffff, devpriv->las0+LAS0_PCLK)
 500
 501 /* Burst counter, 10bit */
 502 #define RtdBurstCount(dev) \
 503     readl (devpriv->las0+LAS0_BCLK)
 504 #define RtdBurstCounter(dev, v) \
 505     writel ((v) & 0x3ff, devpriv->las0+LAS0_BCLK)
 506
 507 /* Delay counter, 16bit */
 508 #define RtdDelayCount(dev) \
 509     readl (devpriv->las0+LAS0_DCLK)
 510 #define RtdDelayCounter(dev, v) \
 511     writel ((v) & 0xffff, devpriv->las0+LAS0_DCLK)
 512
 513 /* About counter, 16bit */
 514 #define RtdAboutCount(dev) \
 515     readl (devpriv->las0+LAS0_ACNT)
 516 #define RtdAboutCounter(dev, v) \
 517     writel ((v) & 0xffff, devpriv->las0+LAS0_ACNT)
 518
 519 /* ADC sample counter, 10bit */
 520 #define RtdAdcSampleCount(dev) \
 521     readl (devpriv->las0+LAS0_ADC_SCNT)
 522 #define RtdAdcSampleCounter(dev, v) \
 523     writel ((v) & 0x3ff, devpriv->las0+LAS0_ADC_SCNT)
 524
 525 /* User Timer/Counter (8254) */
 526 #define RtdUtcCounterGet(dev, n) \
 527     readb (devpriv->las0 \
 528         + ((n <= 0) ? LAS0_UTC0 : ((1 == n) ? LAS0_UTC1 : LAS0_UTC2)))
 529
 530 #define RtdUtcCounterPut(dev, n, v) \
 531     writeb ((v) & 0xff, devpriv->las0 \
 532         + ((n <= 0) ? LAS0_UTC0 : ((1 == n) ? LAS0_UTC1 : LAS0_UTC2)))
 533
 534 /* Set UTC (8254) control byte  */
 535 #define RtdUtcCtrlPut(dev, n, v) \
 536     writeb (devpriv->utcCtrl[(n) & 3] = (((n) & 3) << 6) | ((v) & 0x3f), \
 537       devpriv->las0 + LAS0_UTC_CTRL)
 538
 539 /* Set UTCn clock source (write only) */
 540 #define RtdUtcClockSource(dev, n, v) \
 541     writew (v, devpriv->las0 \
 542         + ((n <= 0) ? LAS0_UTC0_CLOCK : \
 543            ((1 == n) ? LAS0_UTC1_CLOCK : LAS0_UTC2_CLOCK)))
 544
 545 /* Set UTCn gate source (write only) */
 546 #define RtdUtcGateSource(dev, n, v) \
 547     writew (v, devpriv->las0 \
 548         + ((n <= 0) ? LAS0_UTC0_GATE : \
 549            ((1 == n) ? LAS0_UTC1_GATE : LAS0_UTC2_GATE)))
 550
 551 /* User output N source select (write only) */
 552 #define RtdUsrOutSource(dev, n, v) \
 553     writel (v, devpriv->las0+((n <= 0) ? LAS0_UOUT0_SELECT : LAS0_UOUT1_SELECT))
 554
 555 /* Digital IO */
 556 #define RtdDio0Read(dev) \
 557     (readw (devpriv->las0+LAS0_DIO0) & 0xff)
 558 #define RtdDio0Write(dev, v) \
 559     writew ((v) & 0xff, devpriv->las0+LAS0_DIO0)
 560
 561 #define RtdDio1Read(dev) \
 562     (readw (devpriv->las0+LAS0_DIO1) & 0xff)
 563 #define RtdDio1Write(dev, v) \
 564     writew ((v) & 0xff, devpriv->las0+LAS0_DIO1)
 565
 566 #define RtdDioStatusRead(dev) \
 567     (readw (devpriv->las0+LAS0_DIO_STATUS) & 0xff)
 568 #define RtdDioStatusWrite(dev, v) \
 569     writew ((devpriv->dioStatus = (v)), devpriv->las0+LAS0_DIO_STATUS)
 570
 571 #define RtdDio0CtrlRead(dev) \
 572     (readw (devpriv->las0+LAS0_DIO0_CTRL) & 0xff)
 573 #define RtdDio0CtrlWrite(dev, v) \
 574     writew ((v) & 0xff, devpriv->las0+LAS0_DIO0_CTRL)
 575
 576 /* Digital to Analog converter */
 577 /* Write one data value (sign + 12bit + marker bits) */
 578 /* Note: matches what DMA would put.  Actual value << 3 */
 579 #define RtdDacFifoPut(dev, n, v) \
 580     writew ((v), devpriv->las1 +(((n) == 0) ? LAS1_DAC1_FIFO : LAS1_DAC2_FIFO))
 581
 582 /* Start single DAC conversion */
 583 #define RtdDacUpdate(dev, n) \
 584     writew (0, devpriv->las0 +(((n) == 0) ? LAS0_DAC1 : LAS0_DAC2))
 585
 586 /* Start single DAC conversion on both DACs */
 587 #define RtdDacBothUpdate(dev) \
 588     writew (0, devpriv->las0+LAS0_DAC)
 589
 590 /* Set DAC output type and range */
 591 #define RtdDacRange(dev, n, v) \
 592     writew ((v) & 7, devpriv->las0 \
 593         +(((n) == 0) ? LAS0_DAC1_CTRL : LAS0_DAC2_CTRL))
 594
 595 /* Reset DAC FIFO */
 596 #define RtdDacClearFifo(dev, n) \
 597     writel (0, devpriv->las0+(((n) == 0) ? LAS0_DAC1_RESET : LAS0_DAC2_RESET))
 598
 599 /* Set source for DMA 0 (write only, shadow?) */
 600 #define RtdDma0Source(dev, n) \
 601     writel ((n) & 0xf, devpriv->las0+LAS0_DMA0_SRC)
 602
 603 /* Set source for DMA 1 (write only, shadow?) */
 604 #define RtdDma1Source(dev, n) \
 605     writel ((n) & 0xf, devpriv->las0+LAS0_DMA1_SRC)
 606
 607 /* Reset board state for DMA 0 */
 608 #define RtdDma0Reset(dev) \
 609     writel (0, devpriv->las0+LAS0_DMA0_RESET)
 610
 611 /* Reset board state for DMA 1 */
 612 #define RtdDma1Reset(dev) \
 613     writel (0, devpriv->las0+LAS0_DMA1_SRC)
 614
 615 /* PLX9080 interrupt mask and status */
 616 #define RtdPlxInterruptRead(dev) \
 617     readl (devpriv->lcfg+LCFG_ITCSR)
 618 #define RtdPlxInterruptWrite(dev, v) \
 619     writel (v, devpriv->lcfg+LCFG_ITCSR)
 620
 621 /* Set  mode for DMA 0 */
 622 #define RtdDma0Mode(dev, m) \
 623     writel ((m), devpriv->lcfg+LCFG_DMAMODE0)
 624
 625 /* Set PCI address for DMA 0 */
 626 #define RtdDma0PciAddr(dev, a) \
 627     writel ((a), devpriv->lcfg+LCFG_DMAPADR0)
 628
 629 /* Set local address for DMA 0 */
 630 #define RtdDma0LocalAddr(dev, a) \
 631     writel ((a), devpriv->lcfg+LCFG_DMALADR0)
 632
 633 /* Set byte count for DMA 0 */
 634 #define RtdDma0Count(dev, c) \
 635     writel ((c), devpriv->lcfg+LCFG_DMASIZ0)
 636
 637 /* Set next descriptor for DMA 0 */
 638 #define RtdDma0Next(dev, a) \
 639     writel ((a), devpriv->lcfg+LCFG_DMADPR0)
 640
 641 /* Set  mode for DMA 1 */
 642 #define RtdDma1Mode(dev, m) \
 643     writel ((m), devpriv->lcfg+LCFG_DMAMODE1)
 644
 645 /* Set PCI address for DMA 1 */
 646 #define RtdDma1PciAddr(dev, a) \
 647     writel ((a), devpriv->lcfg+LCFG_DMAADR1)
 648
 649 /* Set local address for DMA 1 */
 650 #define RtdDma1LocalAddr(dev, a) \
 651     writel ((a), devpriv->lcfg+LCFG_DMALADR1)
 652
 653 /* Set byte count for DMA 1 */
 654 #define RtdDma1Count(dev, c) \
 655     writel ((c), devpriv->lcfg+LCFG_DMASIZ1)
 656
 657 /* Set next descriptor for DMA 1 */
 658 #define RtdDma1Next(dev, a) \
 659     writel ((a), devpriv->lcfg+LCFG_DMADPR1)
 660
 661 /* Set control for DMA 0 (write only, shadow?) */
 662 #define RtdDma0Control(dev, n) \
 663     writeb (devpriv->dma0Control = (n), devpriv->lcfg+LCFG_DMACSR0)
 664
 665 /* Get status for DMA 0 */
 666 #define RtdDma0Status(dev) \
 667     readb (devpriv->lcfg+LCFG_DMACSR0)
 668
 669 /* Set control for DMA 1 (write only, shadow?) */
 670 #define RtdDma1Control(dev, n) \
 671     writeb (devpriv->dma1Control = (n), devpriv->lcfg+LCFG_DMACSR1)
 672
 673 /* Get status for DMA 1 */
 674 #define RtdDma1Status(dev) \
 675     readb (devpriv->lcfg+LCFG_DMACSR1)
 676
 677 /*
 678  * The struct comedi_driver structure tells the Comedi core module
 679  * which functions to call to configure/deconfigure (attac/detach)
 680  * the board, and also about the kernel module that contains
 681  * the device code.
 682  */
 683 static int rtd_attach(struct comedi_device *dev, struct comedi_devconfig *it);
 684 static int rtd_detach(struct comedi_device *dev);
 685
 686 static struct comedi_driver rtd520Driver = {
 687         .driver_name = DRV_NAME,
 688         .module = THIS_MODULE,
 689         .attach = rtd_attach,
 690         .detach = rtd_detach,
 691 };
 692
 693 static int rtd_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
 694         struct comedi_insn *insn, unsigned int *data);
 695 static int rtd_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
 696         struct comedi_insn *insn, unsigned int *data);
 697 static int rtd_ao_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
 698         struct comedi_insn *insn, unsigned int *data);
 699 static int rtd_dio_insn_bits(struct comedi_device *dev, struct comedi_subdevice *s,
 700         struct comedi_insn *insn, unsigned int *data);
 701 static int rtd_dio_insn_config(struct comedi_device *dev, struct comedi_subdevice *s,
 702         struct comedi_insn *insn, unsigned int *data);
 703 static int rtd_ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
 704         struct comedi_cmd *cmd);
 705 static int rtd_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
 706 static int rtd_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
 707 /* static int rtd_ai_poll (struct comedi_device *dev,struct comedi_subdevice *s); */
 708 static int rtd_ns_to_timer(unsigned int *ns, int roundMode);
 709 static irqreturn_t rtd_interrupt(int irq, void *d);
 710 static int rtd520_probe_fifo_depth(struct comedi_device *dev);
 711
 712 /*
 713  * Attach is called by the Comedi core to configure the driver
 714  * for a particular board.  If you specified a board_name array
 715  * in the driver structure, dev->board_ptr contains that
 716  * address.
 717  */
 718 static int rtd_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 719 {                               /* board name and options flags */
 720         struct comedi_subdevice *s;
 721         struct pci_dev *pcidev;
 722         int ret;
 723         resource_size_t physLas0;       /* configuation */
 724         resource_size_t physLas1;       /* data area */
 725         resource_size_t physLcfg;       /* PLX9080 */
 726 #ifdef USE_DMA
 727         int index;
 728 #endif
 729
 730         printk("comedi%d: rtd520 attaching.\n", dev->minor);
 731
 732 #if defined (CONFIG_COMEDI_DEBUG) && defined (USE_DMA)
 733         /* You can set this a load time: modprobe comedi comedi_debug=1 */
 734         if (0 == comedi_debug)  /* force DMA debug printks */
 735                 comedi_debug = 1;
 736 #endif
 737
 738         /*
 739          * Allocate the private structure area.  alloc_private() is a
 740          * convenient macro defined in comedidev.h.
 741          */
 742         if (alloc_private(dev, sizeof(struct rtdPrivate)) < 0)
 743                 return -ENOMEM;
 744
 745         /*
 746          * Probe the device to determine what device in the series it is.
 747          */
 748         for (pcidev = pci_get_device(PCI_VENDOR_ID_RTD, PCI_ANY_ID, NULL);
 749                 pcidev != NULL;
 750                 pcidev = pci_get_device(PCI_VENDOR_ID_RTD, PCI_ANY_ID, pcidev)) {
 751                 int i;
 752
 753                 if (it->options[0] || it->options[1]) {
 754                         if (pcidev->bus->number != it->options[0]
 755                                 || PCI_SLOT(pcidev->devfn) !=
 756                                 it->options[1]) {
 757                                 continue;
 758                         }
 759                 }
 760                 for (i = 0; i < sizeof (rtd520Boards) / sizeof (rtd520Boards[0]); ++i)
 761                 {
 762                         if (pcidev->device == rtd520Boards[i].device_id)
 763                         {
 764                                 dev->board_ptr = &rtd520Boards[i];
 765                                 break;
 766                         }
 767                 }
 768                 if (dev->board_ptr) break;      /* found one */
 769         }
 770         if (!pcidev) {
 771                 if (it->options[0] && it->options[1]) {
 772                         printk("No RTD card at bus=%d slot=%d.\n",
 773                                 it->options[0], it->options[1]);
 774                 } else {
 775                         printk("No RTD card found.\n");
 776                 }
 777                 return -EIO;
 778         }
 779         devpriv->pci_dev = pcidev;
 780         dev->board_name = thisboard->name;
 781
 782         ret = comedi_pci_enable(pcidev, DRV_NAME);
 783         if (ret < 0) {
 784                 printk("Failed to enable PCI device and request regions.\n");
 785                 return ret;
 786         }
 787         devpriv->got_regions = 1;
 788
 789         /*
 790          * Initialize base addresses
 791          */
 792         /* Get the physical address from PCI config */
 793         physLas0 = pci_resource_start(devpriv->pci_dev, LAS0_PCIINDEX);
 794         physLas1 = pci_resource_start(devpriv->pci_dev, LAS1_PCIINDEX);
 795         physLcfg = pci_resource_start(devpriv->pci_dev, LCFG_PCIINDEX);
 796         /* Now have the kernel map this into memory */
 797         /* ASSUME page aligned */
 798         devpriv->las0 = ioremap_nocache(physLas0, LAS0_PCISIZE);
 799         devpriv->las1 = ioremap_nocache(physLas1, LAS1_PCISIZE);
 800         devpriv->lcfg = ioremap_nocache(physLcfg, LCFG_PCISIZE);
 801
 802         if (!devpriv->las0 || !devpriv->las1 || !devpriv->lcfg) {
 803                 return -ENOMEM;
 804         }
 805
 806         DPRINTK("%s: LAS0=%llx, LAS1=%llx, CFG=%llx.\n", dev->board_name,
 807                 (unsigned long long)physLas0, (unsigned long long)physLas1,
 808                 (unsigned long long)physLcfg);
 809         {                       /* The RTD driver does this */
 810                 unsigned char pci_latency;
 811                 u16 revision;
 812                 /*uint32_t epld_version; */
 813
 814                 pci_read_config_word(devpriv->pci_dev, PCI_REVISION_ID,
 815                         &revision);
 816                 DPRINTK("%s: PCI revision %d.\n", dev->board_name, revision);
 817
 818                 pci_read_config_byte(devpriv->pci_dev,
 819                         PCI_LATENCY_TIMER, &pci_latency);
 820                 if (pci_latency < 32) {
 821                         printk("%s: PCI latency changed from %d to %d\n",
 822                                 dev->board_name, pci_latency, 32);
 823                         pci_write_config_byte(devpriv->pci_dev,
 824                                 PCI_LATENCY_TIMER, 32);
 825                 } else {
 826                         DPRINTK("rtd520: PCI latency = %d\n", pci_latency);
 827                 }
 828
 829                 /* Undocumented EPLD version (doesnt match RTD driver results) */
 830                 /*DPRINTK ("rtd520: Reading epld from %p\n",
 831                    devpriv->las0+0);
 832                    epld_version = readl (devpriv->las0+0);
 833                    if ((epld_version & 0xF0) >> 4 == 0x0F) {
 834                    DPRINTK("rtd520: pre-v8 EPLD. (%x)\n", epld_version);
 835                    } else {
 836                    DPRINTK("rtd520: EPLD version %x.\n", epld_version >> 4);
 837                    } */
 838         }
 839
 840         /* Show board configuration */
 841         printk("%s:", dev->board_name);
 842
 843         /*
 844          * Allocate the subdevice structures.  alloc_subdevice() is a
 845          * convenient macro defined in comedidev.h.
 846          */
 847         if (alloc_subdevices(dev, 4) < 0) {
 848                 return -ENOMEM;
 849         }
 850
 851         s = dev->subdevices + 0;
 852         dev->read_subdev = s;
 853         /* analog input subdevice */
 854         s->type = COMEDI_SUBD_AI;
 855         s->subdev_flags =
 856                 SDF_READABLE | SDF_GROUND | SDF_COMMON | SDF_DIFF |
 857                 SDF_CMD_READ;
 858         s->n_chan = thisboard->aiChans;
 859         s->maxdata = (1 << thisboard->aiBits) - 1;
 860         if (thisboard->aiMaxGain <= 32) {
 861                 s->range_table = &rtd_ai_7520_range;
 862         } else {
 863                 s->range_table = &rtd_ai_4520_range;
 864         }
 865         s->len_chanlist = RTD_MAX_CHANLIST;     /* devpriv->fifoLen */
 866         s->insn_read = rtd_ai_rinsn;
 867         s->do_cmd = rtd_ai_cmd;
 868         s->do_cmdtest = rtd_ai_cmdtest;
 869         s->cancel = rtd_ai_cancel;
 870         /* s->poll = rtd_ai_poll; */ /* not ready yet */
 871
 872         s = dev->subdevices + 1;
 873         /* analog output subdevice */
 874         s->type = COMEDI_SUBD_AO;
 875         s->subdev_flags = SDF_WRITABLE;
 876         s->n_chan = 2;
 877         s->maxdata = (1 << thisboard->aiBits) - 1;
 878         s->range_table = &rtd_ao_range;
 879         s->insn_write = rtd_ao_winsn;
 880         s->insn_read = rtd_ao_rinsn;
 881
 882         s = dev->subdevices + 2;
 883         /* digital i/o subdevice */
 884         s->type = COMEDI_SUBD_DIO;
 885         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 886         /* we only support port 0 right now.  Ignoring port 1 and user IO */
 887         s->n_chan = 8;
 888         s->maxdata = 1;
 889         s->range_table = &range_digital;
 890         s->insn_bits = rtd_dio_insn_bits;
 891         s->insn_config = rtd_dio_insn_config;
 892
 893         /* timer/counter subdevices (not currently supported) */
 894         s = dev->subdevices + 3;
 895         s->type = COMEDI_SUBD_COUNTER;
 896         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 897         s->n_chan = 3;
 898         s->maxdata = 0xffff;
 899
 900         /* initialize board, per RTD spec */
 901         /* also, initialize shadow registers */
 902         RtdResetBoard(dev);
 903         comedi_udelay(100);     /* needed? */
 904         RtdPlxInterruptWrite(dev, 0);
 905         RtdInterruptMask(dev, 0);       /* and sets shadow */
 906         RtdInterruptClearMask(dev, ~0); /* and sets shadow */
 907         RtdInterruptClear(dev); /* clears bits set by mask */
 908         RtdInterruptOverrunClear(dev);
 909         RtdClearCGT(dev);
 910         RtdAdcClearFifo(dev);
 911         RtdDacClearFifo(dev, 0);
 912         RtdDacClearFifo(dev, 1);
 913         /* clear digital IO fifo */
 914         RtdDioStatusWrite(dev, 0);      /* safe state, set shadow */
 915         RtdUtcCtrlPut(dev, 0, 0x30);    /* safe state, set shadow */
 916         RtdUtcCtrlPut(dev, 1, 0x30);    /* safe state, set shadow */
 917         RtdUtcCtrlPut(dev, 2, 0x30);    /* safe state, set shadow */
 918         RtdUtcCtrlPut(dev, 3, 0);       /* safe state, set shadow */
 919         /* TODO: set user out source ??? */
 920
 921         /* check if our interrupt is available and get it */
 922         ret = comedi_request_irq(devpriv->pci_dev->irq, rtd_interrupt,
 923                                  IRQF_SHARED, DRV_NAME, dev);
 924
 925         if (ret < 0) {
 926                 printk("Could not get interrupt! (%u)\n",
 927                         devpriv->pci_dev->irq);
 928                 return ret;
 929         }
 930         dev->irq = devpriv->pci_dev->irq;
 931         printk("( irq=%u )", dev->irq);
 932
 933         ret = rtd520_probe_fifo_depth(dev);
 934         if (ret < 0) {
 935                 return ret;
 936         }
 937         devpriv->fifoLen = ret;
 938         printk("( fifoLen=%d )", devpriv->fifoLen);
 939
 940 #ifdef USE_DMA
 941         if (dev->irq > 0) {
 942                 printk("( DMA buff=%d )\n", DMA_CHAIN_COUNT);
 943                 /* The PLX9080 has 2 DMA controllers, but there could be 4 sources:
 944                    ADC, digital, DAC1, and DAC2.  Since only the ADC supports cmd mode
 945                    right now, this isn't an issue (yet) */
 946                 devpriv->dma0Offset = 0;
 947
 948                 for (index = 0; index < DMA_CHAIN_COUNT; index++) {
 949                         devpriv->dma0Buff[index] =
 950                                 pci_alloc_consistent(devpriv->pci_dev,
 951                                 sizeof(u16) * devpriv->fifoLen / 2,
 952                                 &devpriv->dma0BuffPhysAddr[index]);
 953                         if (devpriv->dma0Buff[index] == NULL) {
 954                                 ret = -ENOMEM;
 955                                 goto rtd_attach_die_error;
 956                         }
 957                         /*DPRINTK ("buff[%d] @ %p virtual, %x PCI\n",
 958                            index,
 959                            devpriv->dma0Buff[index], devpriv->dma0BuffPhysAddr[index]); */
 960                 }
 961
 962                 /* setup DMA descriptor ring (use cpu_to_le32 for byte ordering?) */
 963                 devpriv->dma0Chain =
 964                         pci_alloc_consistent(devpriv->pci_dev,
 965                         sizeof(struct plx_dma_desc) * DMA_CHAIN_COUNT,
 966                         &devpriv->dma0ChainPhysAddr);
 967                 for (index = 0; index < DMA_CHAIN_COUNT; index++) {
 968                         devpriv->dma0Chain[index].pci_start_addr =
 969                                 devpriv->dma0BuffPhysAddr[index];
 970                         devpriv->dma0Chain[index].local_start_addr =
 971                                 DMALADDR_ADC;
 972                         devpriv->dma0Chain[index].transfer_size =
 973                                 sizeof(u16) * devpriv->fifoLen / 2;
 974                         devpriv->dma0Chain[index].next =
 975                                 (devpriv->dma0ChainPhysAddr + ((index +
 976                                                 1) % (DMA_CHAIN_COUNT))
 977                                 * sizeof(devpriv->dma0Chain[0]))
 978                                 | DMA_TRANSFER_BITS;
 979                         /*DPRINTK ("ring[%d] @%lx PCI: %x, local: %x, N: 0x%x, next: %x\n",
 980                            index,
 981                            ((long)devpriv->dma0ChainPhysAddr
 982                            + (index * sizeof(devpriv->dma0Chain[0]))),
 983                            devpriv->dma0Chain[index].pci_start_addr,
 984                            devpriv->dma0Chain[index].local_start_addr,
 985                            devpriv->dma0Chain[index].transfer_size,
 986                            devpriv->dma0Chain[index].next); */
 987                 }
 988
 989                 if (devpriv->dma0Chain == NULL) {
 990                         ret = -ENOMEM;
 991                         goto rtd_attach_die_error;
 992                 }
 993
 994                 RtdDma0Mode(dev, DMA_MODE_BITS);
 995                 RtdDma0Source(dev, DMAS_ADFIFO_HALF_FULL);      /* set DMA trigger source */
 996         } else {
 997                 printk("( no IRQ->no DMA )");
 998         }
 999 #endif /* USE_DMA */
1000
1001         if (dev->irq) {         /* enable plx9080 interrupts */
1002                 RtdPlxInterruptWrite(dev, ICS_PIE | ICS_PLIE);
1003         }
1004
1005         printk("\ncomedi%d: rtd520 driver attached.\n", dev->minor);
1006
1007         return 1;
1008
1009 #if 0
1010         /* hit an error, clean up memory and return ret */
1011 /* rtd_attach_die_error: */
1012 #ifdef USE_DMA
1013         for (index = 0; index < DMA_CHAIN_COUNT; index++) {
1014                 if (NULL != devpriv->dma0Buff[index]) { /* free buffer memory */
1015                         pci_free_consistent(devpriv->pci_dev,
1016                                 sizeof(u16) * devpriv->fifoLen / 2,
1017                                 devpriv->dma0Buff[index],
1018                                 devpriv->dma0BuffPhysAddr[index]);
1019                         devpriv->dma0Buff[index] = NULL;
1020                 }
1021         }
1022         if (NULL != devpriv->dma0Chain) {
1023                 pci_free_consistent(devpriv->pci_dev,
1024                         sizeof(struct plx_dma_desc)
1025                         * DMA_CHAIN_COUNT,
1026                         devpriv->dma0Chain, devpriv->dma0ChainPhysAddr);
1027                 devpriv->dma0Chain = NULL;
1028         }
1029 #endif /* USE_DMA */
1030         /* subdevices and priv are freed by the core */
1031         if (dev->irq) {
1032                 /* disable interrupt controller */
1033                 RtdPlxInterruptWrite(dev, RtdPlxInterruptRead(dev)
1034                         & ~(ICS_PLIE | ICS_DMA0_E | ICS_DMA1_E));
1035                 comedi_free_irq(dev->irq, dev);
1036         }
1037
1038         /* release all regions that were allocated */
1039         if (devpriv->las0) {
1040                 iounmap(devpriv->las0);
1041         }
1042         if (devpriv->las1) {
1043                 iounmap(devpriv->las1);
1044         }
1045         if (devpriv->lcfg) {
1046                 iounmap(devpriv->lcfg);
1047         }
1048         if (devpriv->pci_dev) {
1049                 pci_dev_put(devpriv->pci_dev);
1050         }
1051         return ret;
1052 #endif
1053 }
1054
1055 /*
1056  * _detach is called to deconfigure a device.  It should deallocate
1057  * resources.
1058  * This function is also called when _attach() fails, so it should be
1059  * careful not to release resources that were not necessarily
1060  * allocated by _attach().  dev->private and dev->subdevices are
1061  * deallocated automatically by the core.
1062  */
1063 static int rtd_detach(struct comedi_device *dev)
1064 {
1065 #ifdef USE_DMA
1066         int index;
1067 #endif
1068
1069         DPRINTK("comedi%d: rtd520: removing (%ld ints)\n",
1070                 dev->minor, (devpriv ? devpriv->intCount : 0L));
1071         if (devpriv && devpriv->lcfg) {
1072                 DPRINTK("(int status 0x%x, overrun status 0x%x, fifo status 0x%x)...\n", 0xffff & RtdInterruptStatus(dev), 0xffff & RtdInterruptOverrunStatus(dev), (0xffff & RtdFifoStatus(dev)) ^ 0x6666);
1073         }
1074
1075         if (devpriv) {
1076                 /* Shut down any board ops by resetting it */
1077 #ifdef USE_DMA
1078                 if (devpriv->lcfg) {
1079                         RtdDma0Control(dev, 0); /* disable DMA */
1080                         RtdDma1Control(dev, 0); /* disable DMA */
1081                         RtdPlxInterruptWrite(dev, ICS_PIE | ICS_PLIE);
1082                 }
1083 #endif /* USE_DMA */
1084                 if (devpriv->las0) {
1085                         RtdResetBoard(dev);
1086                         RtdInterruptMask(dev, 0);
1087                         RtdInterruptClearMask(dev, ~0);
1088                         RtdInterruptClear(dev); /* clears bits set by mask */
1089                 }
1090 #ifdef USE_DMA
1091                 /* release DMA */
1092                 for (index = 0; index < DMA_CHAIN_COUNT; index++) {
1093                         if (NULL != devpriv->dma0Buff[index]) {
1094                                 pci_free_consistent(devpriv->pci_dev,
1095                                         sizeof(u16) * devpriv->fifoLen / 2,
1096                                         devpriv->dma0Buff[index],
1097                                         devpriv->dma0BuffPhysAddr[index]);
1098                                 devpriv->dma0Buff[index] = NULL;
1099                         }
1100                 }
1101                 if (NULL != devpriv->dma0Chain) {
1102                         pci_free_consistent(devpriv->pci_dev,
1103                                 sizeof(struct plx_dma_desc) * DMA_CHAIN_COUNT,
1104                                 devpriv->dma0Chain, devpriv->dma0ChainPhysAddr);
1105                         devpriv->dma0Chain = NULL;
1106                 }
1107 #endif /* USE_DMA */
1108
1109                 /* release IRQ */
1110                 if (dev->irq) {
1111                         /* disable interrupt controller */
1112                         RtdPlxInterruptWrite(dev, RtdPlxInterruptRead(dev)
1113                                 & ~(ICS_PLIE | ICS_DMA0_E | ICS_DMA1_E));
1114                         comedi_free_irq(dev->irq, dev);
1115                 }
1116
1117                 /* release all regions that were allocated */
1118                 if (devpriv->las0) {
1119                         iounmap(devpriv->las0);
1120                 }
1121                 if (devpriv->las1) {
1122                         iounmap(devpriv->las1);
1123                 }
1124                 if (devpriv->lcfg) {
1125                         iounmap(devpriv->lcfg);
1126                 }
1127                 if (devpriv->pci_dev) {
1128                         if (devpriv->got_regions) {
1129                                 comedi_pci_disable(devpriv->pci_dev);
1130                         }
1131                         pci_dev_put(devpriv->pci_dev);
1132                 }
1133         }
1134
1135         printk("comedi%d: rtd520: removed.\n", dev->minor);
1136
1137         return 0;
1138 }
1139
1140 /*
1141   Convert a single comedi channel-gain entry to a RTD520 table entry
1142 */
1143 static unsigned short rtdConvertChanGain(struct comedi_device *dev,
1144         unsigned int comediChan, int chanIndex)
1145 {                               /* index in channel list */
1146         unsigned int chan, range, aref;
1147         unsigned short r = 0;
1148
1149         chan = CR_CHAN(comediChan);
1150         range = CR_RANGE(comediChan);
1151         aref = CR_AREF(comediChan);
1152
1153         r |= chan & 0xf;
1154
1155         /* Note: we also setup the channel list bipolar flag array */
1156         if (range < thisboard->range10Start) {  /* first batch are +-5 */
1157                 r |= 0x000;     /* +-5 range */
1158                 r |= (range & 0x7) << 4;        /* gain */
1159                 CHAN_ARRAY_SET(devpriv->chanBipolar, chanIndex);
1160         } else if (range < thisboard->rangeUniStart) {  /* second batch are +-10 */
1161                 r |= 0x100;     /* +-10 range */
1162                 r |= ((range - thisboard->range10Start) & 0x7) << 4;    /* gain */
1163                 CHAN_ARRAY_SET(devpriv->chanBipolar, chanIndex);
1164         } else {                /* last batch is +10 */
1165                 r |= 0x200;     /* +10 range */
1166                 r |= ((range - thisboard->rangeUniStart) & 0x7) << 4;   /* gain */
1167                 CHAN_ARRAY_CLEAR(devpriv->chanBipolar, chanIndex);
1168         }
1169
1170         switch (aref) {
1171         case AREF_GROUND:       /* on-board ground */
1172                 break;
1173
1174         case AREF_COMMON:
1175                 r |= 0x80;      /* ref external analog common */
1176                 break;
1177
1178         case AREF_DIFF:
1179                 r |= 0x400;     /* differential inputs */
1180                 break;
1181
1182         case AREF_OTHER:        /* ??? */
1183                 break;
1184         }
1185         /*printk ("chan=%d r=%d a=%d -> 0x%x\n",
1186            chan, range, aref, r); */
1187         return r;
1188 }
1189
1190 /*
1191   Setup the channel-gain table from a comedi list
1192 */
1193 static void rtd_load_channelgain_list(struct comedi_device *dev,
1194         unsigned int n_chan, unsigned int *list)
1195 {
1196         if (n_chan > 1) {       /* setup channel gain table */
1197                 int ii;
1198                 RtdClearCGT(dev);
1199                 RtdEnableCGT(dev, 1);   /* enable table */
1200                 for (ii = 0; ii < n_chan; ii++) {
1201                         RtdWriteCGTable(dev, rtdConvertChanGain(dev, list[ii],
1202                                         ii));
1203                 }
1204         } else {                /* just use the channel gain latch */
1205                 RtdEnableCGT(dev, 0);   /* disable table, enable latch */
1206                 RtdWriteCGLatch(dev, rtdConvertChanGain(dev, list[0], 0));
1207         }
1208 }
1209
1210 /* determine fifo size by doing adc conversions until the fifo half
1211 empty status flag clears */
1212 static int rtd520_probe_fifo_depth(struct comedi_device *dev)
1213 {
1214         unsigned int chanspec = CR_PACK(0, 0, AREF_GROUND);
1215         unsigned i;
1216         static const unsigned limit = 0x2000;
1217         unsigned fifo_size = 0;
1218
1219         RtdAdcClearFifo(dev);
1220         rtd_load_channelgain_list(dev, 1, &chanspec);
1221         RtdAdcConversionSource(dev, 0); /* software */
1222         /* convert  samples */
1223         for (i = 0; i < limit; ++i) {
1224                 unsigned fifo_status;
1225                 /* trigger conversion */
1226                 RtdAdcStart(dev);
1227                 comedi_udelay(1);
1228                 fifo_status = RtdFifoStatus(dev);
1229                 if ((fifo_status & FS_ADC_HEMPTY) == 0) {
1230                         fifo_size = 2 * i;
1231                         break;
1232                 }
1233         }
1234         if (i == limit)
1235         {
1236                 rt_printk("\ncomedi: %s: failed to probe fifo size.\n", DRV_NAME);
1237                 return -EIO;
1238         }
1239         RtdAdcClearFifo(dev);
1240         if (fifo_size != 0x400 && fifo_size != 0x2000)
1241         {
1242                 rt_printk("\ncomedi: %s: unexpected fifo size of %i, expected 1024 or 8192.\n",
1243                         DRV_NAME, fifo_size);
1244                 return -EIO;
1245         }
1246         return fifo_size;
1247 }
1248
1249 /*
1250   "instructions" read/write data in "one-shot" or "software-triggered"
1251   mode (simplest case).
1252   This doesnt use interrupts.
1253
1254   Note, we don't do any settling delays.  Use a instruction list to
1255   select, delay, then read.
1256  */
1257 static int rtd_ai_rinsn(struct comedi_device *dev,
1258         struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data)
1259 {
1260         int n, ii;
1261         int stat;
1262
1263         /* clear any old fifo data */
1264         RtdAdcClearFifo(dev);
1265
1266         /* write channel to multiplexer and clear channel gain table */
1267         rtd_load_channelgain_list(dev, 1, &insn->chanspec);
1268
1269         /* set conversion source */
1270         RtdAdcConversionSource(dev, 0); /* software */
1271
1272         /* convert n samples */
1273         for (n = 0; n < insn->n; n++) {
1274                 s16 d;
1275                 /* trigger conversion */
1276                 RtdAdcStart(dev);
1277
1278                 for (ii = 0; ii < RTD_ADC_TIMEOUT; ++ii) {
1279                         stat = RtdFifoStatus(dev);
1280                         if (stat & FS_ADC_NOT_EMPTY)    /* 1 -> not empty */
1281                                 break;
1282                         WAIT_QUIETLY;
1283                 }
1284                 if (ii >= RTD_ADC_TIMEOUT) {
1285                         DPRINTK("rtd520: Error: ADC never finished! FifoStatus=0x%x\n", stat ^ 0x6666);
1286                         return -ETIMEDOUT;
1287                 }
1288
1289                 /* read data */
1290                 d = RtdAdcFifoGet(dev); /* get 2s comp value */
1291                 /*printk ("rtd520: Got 0x%x after %d usec\n", d, ii+1); */
1292                 d = d >> 3;     /* low 3 bits are marker lines */
1293                 if (CHAN_ARRAY_TEST(devpriv->chanBipolar, 0)) {
1294                         data[n] = d + 2048;     /* convert to comedi unsigned data */
1295                 } else {
1296                         data[n] = d;
1297                 }
1298         }
1299
1300         /* return the number of samples read/written */
1301         return n;
1302 }
1303
1304 /*
1305   Get what we know is there.... Fast!
1306   This uses 1/2 the bus cycles of read_dregs (below).
1307
1308   The manual claims that we can do a lword read, but it doesn't work here.
1309 */
1310 static int ai_read_n(struct comedi_device *dev, struct comedi_subdevice *s, int count)
1311 {
1312         int ii;
1313
1314         for (ii = 0; ii < count; ii++) {
1315                 short sample;
1316                 s16 d;
1317
1318                 if (0 == devpriv->aiCount) {    /* done */
1319                         d = RtdAdcFifoGet(dev); /* Read N and discard */
1320                         continue;
1321                 }
1322 #if 0
1323                 if (0 == (RtdFifoStatus(dev) & FS_ADC_NOT_EMPTY)) {     /* DEBUG */
1324                         DPRINTK("comedi: READ OOPS on %d of %d\n", ii + 1,
1325                                 count);
1326                         break;
1327                 }
1328 #endif
1329                 d = RtdAdcFifoGet(dev); /* get 2s comp value */
1330
1331                 d = d >> 3;     /* low 3 bits are marker lines */
1332                 if (CHAN_ARRAY_TEST(devpriv->chanBipolar, s->async->cur_chan)) {
1333                         sample = d + 2048;      /* convert to comedi unsigned data */
1334                 } else {
1335                         sample = d;
1336                 }
1337                 if (!comedi_buf_put(s->async, sample))
1338                         return -1;
1339
1340                 if (devpriv->aiCount > 0)       /* < 0, means read forever */
1341                         devpriv->aiCount--;
1342         }
1343         return 0;
1344 }
1345
1346 /*
1347   unknown amout of data is waiting in fifo.
1348 */
1349 static int ai_read_dregs(struct comedi_device *dev, struct comedi_subdevice *s)
1350 {
1351         while (RtdFifoStatus(dev) & FS_ADC_NOT_EMPTY) { /* 1 -> not empty */
1352                 short sample;
1353                 s16 d = RtdAdcFifoGet(dev);     /* get 2s comp value */
1354
1355                 if (0 == devpriv->aiCount) {    /* done */
1356                         continue;       /* read rest */
1357                 }
1358
1359                 d = d >> 3;     /* low 3 bits are marker lines */
1360                 if (CHAN_ARRAY_TEST(devpriv->chanBipolar, s->async->cur_chan)) {
1361                         sample = d + 2048;      /* convert to comedi unsigned data */
1362                 } else {
1363                         sample = d;
1364                 }
1365                 if (!comedi_buf_put(s->async, sample))
1366                         return -1;
1367
1368                 if (devpriv->aiCount > 0)       /* < 0, means read forever */
1369                         devpriv->aiCount--;
1370         }
1371         return 0;
1372 }
1373
1374 #ifdef USE_DMA
1375 /*
1376   Terminate a DMA transfer and wait for everything to quiet down
1377 */
1378 void abort_dma(struct comedi_device *dev, unsigned int channel)
1379 {                               /* DMA channel 0, 1 */
1380         unsigned long dma_cs_addr;      /* the control/status register */
1381         uint8_t status;
1382         unsigned int ii;
1383         /* unsigned long flags; */
1384
1385         dma_cs_addr = (unsigned long)devpriv->lcfg
1386                 + ((channel == 0) ? LCFG_DMACSR0 : LCFG_DMACSR1);
1387
1388         /*  spinlock for plx dma control/status reg */
1389         /* comedi_spin_lock_irqsave( &dev->spinlock, flags ); */
1390
1391         /*  abort dma transfer if necessary */
1392         status = readb(dma_cs_addr);
1393         if ((status & PLX_DMA_EN_BIT) == 0) {   /* not enabled (Error?) */
1394                 DPRINTK("rtd520: AbortDma on non-active channel %d (0x%x)\n",
1395                         channel, status);
1396                 goto abortDmaExit;
1397         }
1398
1399         /* wait to make sure done bit is zero (needed?) */
1400         for (ii = 0; (status & PLX_DMA_DONE_BIT) && ii < RTD_DMA_TIMEOUT; ii++) {
1401                 WAIT_QUIETLY;
1402                 status = readb(dma_cs_addr);
1403         }
1404         if (status & PLX_DMA_DONE_BIT) {
1405                 printk("rtd520: Timeout waiting for dma %i done clear\n",
1406                         channel);
1407                 goto abortDmaExit;
1408         }
1409
1410         /* disable channel (required) */
1411         writeb(0, dma_cs_addr);
1412         comedi_udelay(1);       /* needed?? */
1413         /* set abort bit for channel */
1414         writeb(PLX_DMA_ABORT_BIT, dma_cs_addr);
1415
1416         /*  wait for dma done bit to be set */
1417         status = readb(dma_cs_addr);
1418         for (ii = 0;
1419                 (status & PLX_DMA_DONE_BIT) == 0 && ii < RTD_DMA_TIMEOUT;
1420                 ii++) {
1421                 status = readb(dma_cs_addr);
1422                 WAIT_QUIETLY;
1423         }
1424         if ((status & PLX_DMA_DONE_BIT) == 0) {
1425                 printk("rtd520: Timeout waiting for dma %i done set\n",
1426                         channel);
1427         }
1428
1429       abortDmaExit:
1430         /* comedi_spin_unlock_irqrestore( &dev->spinlock, flags ); */
1431 }
1432
1433 /*
1434   Process what is in the DMA transfer buffer and pass to comedi
1435   Note: this is not re-entrant
1436 */
1437 static int ai_process_dma(struct comedi_device *dev, struct comedi_subdevice *s)
1438 {
1439         int ii, n;
1440         s16 *dp;
1441
1442         if (devpriv->aiCount == 0)      /* transfer already complete */
1443                 return 0;
1444
1445         dp = devpriv->dma0Buff[devpriv->dma0Offset];
1446         for (ii = 0; ii < devpriv->fifoLen / 2;) {      /* convert samples */
1447                 short sample;
1448
1449                 if (CHAN_ARRAY_TEST(devpriv->chanBipolar, s->async->cur_chan)) {
1450                         sample = (*dp >> 3) + 2048;     /* convert to comedi unsigned data */
1451                 } else {
1452                         sample = *dp >> 3;      /* low 3 bits are marker lines */
1453                 }
1454                 *dp++ = sample; /* put processed value back */
1455
1456                 if (++s->async->cur_chan >= s->async->cmd.chanlist_len)
1457                         s->async->cur_chan = 0;
1458
1459                 ++ii;           /* number ready to transfer */
1460                 if (devpriv->aiCount > 0) {     /* < 0, means read forever */
1461                         if (--devpriv->aiCount == 0) {  /* done */
1462                                 /*DPRINTK ("rtd520: Final %d samples\n", ii); */
1463                                 break;
1464                         }
1465                 }
1466         }
1467
1468         /* now pass the whole array to the comedi buffer */
1469         dp = devpriv->dma0Buff[devpriv->dma0Offset];
1470         n = comedi_buf_write_alloc(s->async, ii * sizeof(s16));
1471         if (n < (ii * sizeof(s16))) {   /* any residual is an error */
1472                 DPRINTK("rtd520:ai_process_dma buffer overflow %d samples!\n",
1473                         ii - (n / sizeof(s16)));
1474                 s->async->events |= COMEDI_CB_ERROR;
1475                 return -1;
1476         }
1477         comedi_buf_memcpy_to(s->async, 0, dp, n);
1478         comedi_buf_write_free(s->async, n);
1479
1480         /* always at least 1 scan -- 1/2 FIFO is larger than our max scan list */
1481         s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
1482
1483         if (++devpriv->dma0Offset >= DMA_CHAIN_COUNT) { /* next buffer */
1484                 devpriv->dma0Offset = 0;
1485         }
1486         return 0;
1487 }
1488 #endif /* USE_DMA */
1489
1490 /*
1491   Handle all rtd520 interrupts.
1492   Runs atomically and is never re-entered.
1493   This is a "slow handler";  other interrupts may be active.
1494   The data conversion may someday happen in a "bottom half".
1495 */
1496 static irqreturn_t rtd_interrupt(int irq,       /* interrupt number (ignored) */
1497         void *d)                /* our data */
1498 {                               /* cpu context (ignored) */
1499         struct comedi_device *dev = d;  /* must be called "dev" for devpriv */
1500         u16 status;
1501         u16 fifoStatus;
1502         struct comedi_subdevice *s = dev->subdevices + 0;       /* analog in subdevice */
1503
1504         if (!dev->attached) {
1505                 return IRQ_NONE;
1506         }
1507
1508         devpriv->intCount++;    /* DEBUG statistics */
1509
1510         fifoStatus = RtdFifoStatus(dev);
1511         /* check for FIFO full, this automatically halts the ADC! */
1512         if (!(fifoStatus & FS_ADC_NOT_FULL)) {  /* 0 -> full */
1513                 DPRINTK("rtd520: FIFO full! fifo_status=0x%x\n", (fifoStatus ^ 0x6666) & 0x7777);       /* should be all 0s */
1514                 goto abortTransfer;
1515         }
1516 #ifdef USE_DMA
1517         if (devpriv->flags & DMA0_ACTIVE) {     /* Check DMA */
1518                 u32 istatus = RtdPlxInterruptRead(dev);
1519
1520                 if (istatus & ICS_DMA0_A) {
1521                         if (ai_process_dma(dev, s) < 0) {
1522                                 DPRINTK("rtd520: comedi read buffer overflow (DMA) with %ld to go!\n", devpriv->aiCount);
1523                                 RtdDma0Control(dev,
1524                                         (devpriv->
1525                                                 dma0Control &
1526                                                 ~PLX_DMA_START_BIT)
1527                                         | PLX_CLEAR_DMA_INTR_BIT);
1528                                 goto abortTransfer;
1529                         }
1530
1531                         /*DPRINTK ("rtd520: DMA transfer: %ld to go, istatus %x\n",
1532                            devpriv->aiCount, istatus); */
1533                         RtdDma0Control(dev,
1534                                 (devpriv->dma0Control & ~PLX_DMA_START_BIT)
1535                                 | PLX_CLEAR_DMA_INTR_BIT);
1536                         if (0 == devpriv->aiCount) {    /* counted down */
1537                                 DPRINTK("rtd520: Samples Done (DMA).\n");
1538                                 goto transferDone;
1539                         }
1540                         comedi_event(dev, s);
1541                 } else {
1542                         /*DPRINTK ("rtd520: No DMA ready: istatus %x\n", istatus); */
1543                 }
1544         }
1545         /* Fall through and check for other interrupt sources */
1546 #endif /* USE_DMA */
1547
1548         status = RtdInterruptStatus(dev);
1549         /* if interrupt was not caused by our board, or handled above */
1550         if (0 == status) {
1551                 return IRQ_HANDLED;
1552         }
1553
1554         if (status & IRQM_ADC_ABOUT_CNT) {      /* sample count -> read FIFO */
1555                 /* since the priority interrupt controller may have queued a sample
1556                    counter interrupt, even though we have already finished,
1557                    we must handle the possibility that there is no data here */
1558                 if (!(fifoStatus & FS_ADC_HEMPTY)) {    /* 0 -> 1/2 full */
1559                         /*DPRINTK("rtd520: Sample int, reading 1/2FIFO.  fifo_status 0x%x\n",
1560                            (fifoStatus ^ 0x6666) & 0x7777); */
1561                         if (ai_read_n(dev, s, devpriv->fifoLen / 2) < 0) {
1562                                 DPRINTK("rtd520: comedi read buffer overflow (1/2FIFO) with %ld to go!\n", devpriv->aiCount);
1563                                 goto abortTransfer;
1564                         }
1565                         if (0 == devpriv->aiCount) {    /* counted down */
1566                                 DPRINTK("rtd520: Samples Done (1/2). fifo_status was 0x%x\n", (fifoStatus ^ 0x6666) & 0x7777);  /* should be all 0s */
1567                                 goto transferDone;
1568                         }
1569                         comedi_event(dev, s);
1570                 } else if (devpriv->transCount > 0) {   /* read often */
1571                         /*DPRINTK("rtd520: Sample int, reading %d  fifo_status 0x%x\n",
1572                            devpriv->transCount, (fifoStatus ^ 0x6666) & 0x7777); */
1573                         if (fifoStatus & FS_ADC_NOT_EMPTY) {    /* 1 -> not empty */
1574                                 if (ai_read_n(dev, s, devpriv->transCount) < 0) {
1575                                         DPRINTK("rtd520: comedi read buffer overflow (N) with %ld to go!\n", devpriv->aiCount);
1576                                         goto abortTransfer;
1577                                 }
1578                                 if (0 == devpriv->aiCount) {    /* counted down */
1579                                         DPRINTK("rtd520: Samples Done (N). fifo_status was 0x%x\n", (fifoStatus ^ 0x6666) & 0x7777);
1580                                         goto transferDone;
1581                                 }
1582                                 comedi_event(dev, s);
1583                         }
1584                 } else {        /* wait for 1/2 FIFO (old) */
1585                         DPRINTK("rtd520: Sample int.  Wait for 1/2. fifo_status 0x%x\n", (fifoStatus ^ 0x6666) & 0x7777);
1586                 }
1587         } else {
1588                 DPRINTK("rtd520: unknown interrupt source!\n");
1589         }
1590
1591         if (0xffff & RtdInterruptOverrunStatus(dev)) {  /* interrupt overrun */
1592                 DPRINTK("rtd520: Interrupt overrun with %ld to go! over_status=0x%x\n", devpriv->aiCount, 0xffff & RtdInterruptOverrunStatus(dev));
1593                 goto abortTransfer;
1594         }
1595
1596         /* clear the interrupt */
1597         RtdInterruptClearMask(dev, status);
1598         RtdInterruptClear(dev);
1599         return IRQ_HANDLED;
1600
1601       abortTransfer:
1602         RtdAdcClearFifo(dev);   /* clears full flag */
1603         s->async->events |= COMEDI_CB_ERROR;
1604         devpriv->aiCount = 0;   /* stop and don't transfer any more */
1605         /* fall into transferDone */
1606
1607       transferDone:
1608         RtdPacerStopSource(dev, 0);     /* stop on SOFTWARE stop */
1609         RtdPacerStop(dev);      /* Stop PACER */
1610         RtdAdcConversionSource(dev, 0); /* software trigger only */
1611         RtdInterruptMask(dev, 0);       /* mask out SAMPLE */
1612 #ifdef USE_DMA
1613         if (devpriv->flags & DMA0_ACTIVE) {
1614                 RtdPlxInterruptWrite(dev,       /* disable any more interrupts */
1615                         RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
1616                 abort_dma(dev, 0);
1617                 devpriv->flags &= ~DMA0_ACTIVE;
1618                 /* if Using DMA, then we should have read everything by now */
1619                 if (devpriv->aiCount > 0) {
1620                         DPRINTK("rtd520: Lost DMA data! %ld remain\n",
1621                                 devpriv->aiCount);
1622                 }
1623         }
1624 #endif /* USE_DMA */
1625
1626         if (devpriv->aiCount > 0) {     /* there shouldn't be anything left */
1627                 fifoStatus = RtdFifoStatus(dev);
1628                 DPRINTK("rtd520: Finishing up. %ld remain, fifoStat=%x\n", devpriv->aiCount, (fifoStatus ^ 0x6666) & 0x7777);   /* should read all 0s */
1629                 ai_read_dregs(dev, s);  /* read anything left in FIFO */
1630         }
1631
1632         s->async->events |= COMEDI_CB_EOA;      /* signal end to comedi */
1633         comedi_event(dev, s);
1634
1635         /* clear the interrupt */
1636         status = RtdInterruptStatus(dev);
1637         RtdInterruptClearMask(dev, status);
1638         RtdInterruptClear(dev);
1639
1640         fifoStatus = RtdFifoStatus(dev);        /* DEBUG */
1641         DPRINTK("rtd520: Acquisition complete. %ld ints, intStat=%x, overStat=%x\n", devpriv->intCount, status, 0xffff & RtdInterruptOverrunStatus(dev));
1642
1643         return IRQ_HANDLED;
1644 }
1645
1646 #if 0
1647 /*
1648   return the number of samples available
1649 */
1650 static int rtd_ai_poll(struct comedi_device *dev, struct comedi_subdevice *s)
1651 {
1652         /* TODO: This needs to mask interrupts, read_dregs, and then re-enable */
1653         /* Not sure what to do if DMA is active */
1654         return s->async->buf_write_count - s->async->buf_read_count;
1655 }
1656 #endif
1657
1658 /*
1659   cmdtest tests a particular command to see if it is valid.
1660   Using the cmdtest ioctl, a user can create a valid cmd
1661   and then have it executed by the cmd ioctl (asyncronously).
1662
1663   cmdtest returns 1,2,3,4 or 0, depending on which tests
1664   the command passes.
1665 */
1666
1667 static int rtd_ai_cmdtest(struct comedi_device *dev,
1668         struct comedi_subdevice *s, struct comedi_cmd *cmd)
1669 {
1670         int err = 0;
1671         int tmp;
1672
1673         /* step 1: make sure trigger sources are trivially valid */
1674
1675         tmp = cmd->start_src;
1676         cmd->start_src &= TRIG_NOW;
1677         if (!cmd->start_src || tmp != cmd->start_src) {
1678                 err++;
1679         }
1680
1681         tmp = cmd->scan_begin_src;
1682         cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
1683         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) {
1684                 err++;
1685         }
1686
1687         tmp = cmd->convert_src;
1688         cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
1689         if (!cmd->convert_src || tmp != cmd->convert_src) {
1690                 err++;
1691         }
1692
1693         tmp = cmd->scan_end_src;
1694         cmd->scan_end_src &= TRIG_COUNT;
1695         if (!cmd->scan_end_src || tmp != cmd->scan_end_src) {
1696                 err++;
1697         }
1698
1699         tmp = cmd->stop_src;
1700         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1701         if (!cmd->stop_src || tmp != cmd->stop_src) {
1702                 err++;
1703         }
1704
1705         if (err)
1706                 return 1;
1707
1708         /* step 2: make sure trigger sources are unique
1709            and mutually compatible */
1710         /* note that mutual compatiblity is not an issue here */
1711         if (cmd->scan_begin_src != TRIG_TIMER &&
1712                 cmd->scan_begin_src != TRIG_EXT) {
1713                 err++;
1714         }
1715         if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT) {
1716                 err++;
1717         }
1718         if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) {
1719                 err++;
1720         }
1721
1722         if (err) {
1723                 return 2;
1724         }
1725
1726         /* step 3: make sure arguments are trivially compatible */
1727
1728         if (cmd->start_arg != 0) {
1729                 cmd->start_arg = 0;
1730                 err++;
1731         }
1732
1733         if (cmd->scan_begin_src == TRIG_TIMER) {
1734                 /* Note: these are time periods, not actual rates */
1735                 if (1 == cmd->chanlist_len) {   /* no scanning */
1736                         if (cmd->scan_begin_arg < RTD_MAX_SPEED_1) {
1737                                 cmd->scan_begin_arg = RTD_MAX_SPEED_1;
1738                                 rtd_ns_to_timer(&cmd->scan_begin_arg,
1739                                         TRIG_ROUND_UP);
1740                                 err++;
1741                         }
1742                         if (cmd->scan_begin_arg > RTD_MIN_SPEED_1) {
1743                                 cmd->scan_begin_arg = RTD_MIN_SPEED_1;
1744                                 rtd_ns_to_timer(&cmd->scan_begin_arg,
1745                                         TRIG_ROUND_DOWN);
1746                                 err++;
1747                         }
1748                 } else {
1749                         if (cmd->scan_begin_arg < RTD_MAX_SPEED) {
1750                                 cmd->scan_begin_arg = RTD_MAX_SPEED;
1751                                 rtd_ns_to_timer(&cmd->scan_begin_arg,
1752                                         TRIG_ROUND_UP);
1753                                 err++;
1754                         }
1755                         if (cmd->scan_begin_arg > RTD_MIN_SPEED) {
1756                                 cmd->scan_begin_arg = RTD_MIN_SPEED;
1757                                 rtd_ns_to_timer(&cmd->scan_begin_arg,
1758                                         TRIG_ROUND_DOWN);
1759                                 err++;
1760                         }
1761                 }
1762         } else {
1763                 /* external trigger */
1764                 /* should be level/edge, hi/lo specification here */
1765                 /* should specify multiple external triggers */
1766                 if (cmd->scan_begin_arg > 9) {
1767                         cmd->scan_begin_arg = 9;
1768                         err++;
1769                 }
1770         }
1771         if (cmd->convert_src == TRIG_TIMER) {
1772                 if (1 == cmd->chanlist_len) {   /* no scanning */
1773                         if (cmd->convert_arg < RTD_MAX_SPEED_1) {
1774                                 cmd->convert_arg = RTD_MAX_SPEED_1;
1775                                 rtd_ns_to_timer(&cmd->convert_arg,
1776                                         TRIG_ROUND_UP);
1777                                 err++;
1778                         }
1779                         if (cmd->convert_arg > RTD_MIN_SPEED_1) {
1780                                 cmd->convert_arg = RTD_MIN_SPEED_1;
1781                                 rtd_ns_to_timer(&cmd->convert_arg,
1782                                         TRIG_ROUND_DOWN);
1783                                 err++;
1784                         }
1785                 } else {
1786                         if (cmd->convert_arg < RTD_MAX_SPEED) {
1787                                 cmd->convert_arg = RTD_MAX_SPEED;
1788                                 rtd_ns_to_timer(&cmd->convert_arg,
1789                                         TRIG_ROUND_UP);
1790                                 err++;
1791                         }
1792                         if (cmd->convert_arg > RTD_MIN_SPEED) {
1793                                 cmd->convert_arg = RTD_MIN_SPEED;
1794                                 rtd_ns_to_timer(&cmd->convert_arg,
1795                                         TRIG_ROUND_DOWN);
1796                                 err++;
1797                         }
1798                 }
1799         } else {
1800                 /* external trigger */
1801                 /* see above */
1802                 if (cmd->convert_arg > 9) {
1803                         cmd->convert_arg = 9;
1804                         err++;
1805                 }
1806         }
1807
1808 #if 0
1809         if (cmd->scan_end_arg != cmd->chanlist_len) {
1810                 cmd->scan_end_arg = cmd->chanlist_len;
1811                 err++;
1812         }
1813 #endif
1814         if (cmd->stop_src == TRIG_COUNT) {
1815                 /* TODO check for rounding error due to counter wrap */
1816
1817         } else {
1818                 /* TRIG_NONE */
1819                 if (cmd->stop_arg != 0) {
1820                         cmd->stop_arg = 0;
1821                         err++;
1822                 }
1823         }
1824
1825         if (err) {
1826                 return 3;
1827         }
1828
1829         /* step 4: fix up any arguments */
1830
1831         if (cmd->chanlist_len > RTD_MAX_CHANLIST) {
1832                 cmd->chanlist_len = RTD_MAX_CHANLIST;
1833                 err++;
1834         }
1835         if (cmd->scan_begin_src == TRIG_TIMER) {
1836                 tmp = cmd->scan_begin_arg;
1837                 rtd_ns_to_timer(&cmd->scan_begin_arg,
1838                         cmd->flags & TRIG_ROUND_MASK);
1839                 if (tmp != cmd->scan_begin_arg) {
1840                         err++;
1841                 }
1842         }
1843         if (cmd->convert_src == TRIG_TIMER) {
1844                 tmp = cmd->convert_arg;
1845                 rtd_ns_to_timer(&cmd->convert_arg,
1846                         cmd->flags & TRIG_ROUND_MASK);
1847                 if (tmp != cmd->convert_arg) {
1848                         err++;
1849                 }
1850                 if (cmd->scan_begin_src == TRIG_TIMER
1851                         && (cmd->scan_begin_arg
1852                                 < (cmd->convert_arg * cmd->scan_end_arg))) {
1853                         cmd->scan_begin_arg =
1854                                 cmd->convert_arg * cmd->scan_end_arg;
1855                         err++;
1856                 }
1857         }
1858
1859         if (err) {
1860                 return 4;
1861         }
1862
1863         return 0;
1864 }
1865
1866 /*
1867   Execute a analog in command with many possible triggering options.
1868   The data get stored in the async structure of the subdevice.
1869   This is usually done by an interrupt handler.
1870   Userland gets to the data using read calls.
1871 */
1872 static int rtd_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1873 {
1874         struct comedi_cmd *cmd = &s->async->cmd;
1875         int timer;
1876
1877         /* stop anything currently running */
1878         RtdPacerStopSource(dev, 0);     /* stop on SOFTWARE stop */
1879         RtdPacerStop(dev);      /* make sure PACER is stopped */
1880         RtdAdcConversionSource(dev, 0); /* software trigger only */
1881         RtdInterruptMask(dev, 0);
1882 #ifdef USE_DMA
1883         if (devpriv->flags & DMA0_ACTIVE) {     /* cancel anything running */
1884                 RtdPlxInterruptWrite(dev,       /* disable any more interrupts */
1885                         RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
1886                 abort_dma(dev, 0);
1887                 devpriv->flags &= ~DMA0_ACTIVE;
1888                 if (RtdPlxInterruptRead(dev) & ICS_DMA0_A) {    /*clear pending int */
1889                         RtdDma0Control(dev, PLX_CLEAR_DMA_INTR_BIT);
1890                 }
1891         }
1892         RtdDma0Reset(dev);      /* reset onboard state */
1893 #endif /* USE_DMA */
1894         RtdAdcClearFifo(dev);   /* clear any old data */
1895         RtdInterruptOverrunClear(dev);
1896         devpriv->intCount = 0;
1897
1898         if (!dev->irq) {        /* we need interrupts for this */
1899                 DPRINTK("rtd520: ERROR! No interrupt available!\n");
1900                 return -ENXIO;
1901         }
1902
1903         /* start configuration */
1904         /* load channel list and reset CGT */
1905         rtd_load_channelgain_list(dev, cmd->chanlist_len, cmd->chanlist);
1906
1907         /* setup the common case and override if needed */
1908         if (cmd->chanlist_len > 1) {
1909                 /*DPRINTK ("rtd520: Multi channel setup\n"); */
1910                 RtdPacerStartSource(dev, 0);    /* software triggers pacer */
1911                 RtdBurstStartSource(dev, 1);    /* PACER triggers burst */
1912                 RtdAdcConversionSource(dev, 2); /* BURST triggers ADC */
1913         } else {                /* single channel */
1914                 /*DPRINTK ("rtd520: single channel setup\n"); */
1915                 RtdPacerStartSource(dev, 0);    /* software triggers pacer */
1916                 RtdAdcConversionSource(dev, 1); /* PACER triggers ADC */
1917         }
1918         RtdAboutCounter(dev, devpriv->fifoLen / 2 - 1); /* 1/2 FIFO */
1919
1920         if (TRIG_TIMER == cmd->scan_begin_src) {
1921                 /* scan_begin_arg is in nanoseconds */
1922                 /* find out how many samples to wait before transferring */
1923                 if (cmd->flags & TRIG_WAKE_EOS) {
1924                         /* this may generate un-sustainable interrupt rates */
1925                         /* the application is responsible for doing the right thing */
1926                         devpriv->transCount = cmd->chanlist_len;
1927                         devpriv->flags |= SEND_EOS;
1928                 } else {
1929                         /* arrange to transfer data periodically */
1930                         devpriv->transCount
1931                                 =
1932                                 (TRANS_TARGET_PERIOD * cmd->chanlist_len) /
1933                                 cmd->scan_begin_arg;
1934                         if (devpriv->transCount < cmd->chanlist_len) {
1935                                 /* tranfer after each scan (and avoid 0) */
1936                                 devpriv->transCount = cmd->chanlist_len;
1937                         } else {        /* make a multiple of scan length */
1938                                 devpriv->transCount =
1939                                         (devpriv->transCount +
1940                                         cmd->chanlist_len - 1)
1941                                         / cmd->chanlist_len;
1942                                 devpriv->transCount *= cmd->chanlist_len;
1943                         }
1944                         devpriv->flags |= SEND_EOS;
1945                 }
1946                 if (devpriv->transCount >= (devpriv->fifoLen / 2)) {
1947                         /* out of counter range, use 1/2 fifo instead */
1948                         devpriv->transCount = 0;
1949                         devpriv->flags &= ~SEND_EOS;
1950                 } else {
1951                         /* interrupt for each tranfer */
1952                         RtdAboutCounter(dev, devpriv->transCount - 1);
1953                 }
1954
1955                 DPRINTK("rtd520: scanLen=%d tranferCount=%d fifoLen=%d\n  scanTime(ns)=%d flags=0x%x\n", cmd->chanlist_len, devpriv->transCount, devpriv->fifoLen, cmd->scan_begin_arg, devpriv->flags);
1956         } else {                /* unknown timing, just use 1/2 FIFO */
1957                 devpriv->transCount = 0;
1958                 devpriv->flags &= ~SEND_EOS;
1959         }
1960         RtdPacerClockSource(dev, 1);    /* use INTERNAL 8Mhz clock source */
1961         RtdAboutStopEnable(dev, 1);     /* just interrupt, dont stop */
1962
1963         /* BUG??? these look like enumerated values, but they are bit fields */
1964
1965         /* First, setup when to stop */
1966         switch (cmd->stop_src) {
1967         case TRIG_COUNT:        /* stop after N scans */
1968                 devpriv->aiCount = cmd->stop_arg * cmd->chanlist_len;
1969                 if ((devpriv->transCount > 0)
1970                         && (devpriv->transCount > devpriv->aiCount)) {
1971                         devpriv->transCount = devpriv->aiCount;
1972                 }
1973                 break;
1974
1975         case TRIG_NONE: /* stop when cancel is called */
1976                 devpriv->aiCount = -1;  /* read forever */
1977                 break;
1978
1979         default:
1980                 DPRINTK("rtd520: Warning! ignoring stop_src mode %d\n",
1981                         cmd->stop_src);
1982         }
1983
1984         /* Scan timing */
1985         switch (cmd->scan_begin_src) {
1986         case TRIG_TIMER:        /* periodic scanning */
1987                 timer = rtd_ns_to_timer(&cmd->scan_begin_arg,
1988                         TRIG_ROUND_NEAREST);
1989                 /* set PACER clock */
1990                 /*DPRINTK ("rtd520: loading %d into pacer\n", timer); */
1991                 RtdPacerCounter(dev, timer);
1992
1993                 break;
1994
1995         case TRIG_EXT:
1996                 RtdPacerStartSource(dev, 1);    /* EXTERNALy trigger pacer */
1997                 break;
1998
1999         default:
2000                 DPRINTK("rtd520: Warning! ignoring scan_begin_src mode %d\n",
2001                         cmd->scan_begin_src);
2002         }
2003
2004         /* Sample timing within a scan */
2005         switch (cmd->convert_src) {
2006         case TRIG_TIMER:        /* periodic */
2007                 if (cmd->chanlist_len > 1) {    /* only needed for multi-channel */
2008                         timer = rtd_ns_to_timer(&cmd->convert_arg,
2009                                 TRIG_ROUND_NEAREST);
2010                         /* setup BURST clock */
2011                         /*DPRINTK ("rtd520: loading %d into burst\n", timer); */
2012                         RtdBurstCounter(dev, timer);
2013                 }
2014
2015                 break;
2016
2017         case TRIG_EXT:          /* external */
2018                 RtdBurstStartSource(dev, 2);    /* EXTERNALy trigger burst */
2019                 break;
2020
2021         default:
2022                 DPRINTK("rtd520: Warning! ignoring convert_src mode %d\n",
2023                         cmd->convert_src);
2024         }
2025         /* end configuration */
2026
2027         /* This doesn't seem to work.  There is no way to clear an interrupt
2028            that the priority controller has queued! */
2029         RtdInterruptClearMask(dev, ~0); /* clear any existing flags */
2030         RtdInterruptClear(dev);
2031
2032         /* TODO: allow multiple interrupt sources */
2033         if (devpriv->transCount > 0) {  /* transfer every N samples */
2034                 RtdInterruptMask(dev, IRQM_ADC_ABOUT_CNT);
2035                 DPRINTK("rtd520: Transferring every %d\n", devpriv->transCount);
2036         } else {                /* 1/2 FIFO transfers */
2037 #ifdef USE_DMA
2038                 devpriv->flags |= DMA0_ACTIVE;
2039
2040                 /* point to first transfer in ring */
2041                 devpriv->dma0Offset = 0;
2042                 RtdDma0Mode(dev, DMA_MODE_BITS);
2043                 RtdDma0Next(dev,        /* point to first block */
2044                         devpriv->dma0Chain[DMA_CHAIN_COUNT - 1].next);
2045                 RtdDma0Source(dev, DMAS_ADFIFO_HALF_FULL);      /* set DMA trigger source */
2046
2047                 RtdPlxInterruptWrite(dev,       /* enable interrupt */
2048                         RtdPlxInterruptRead(dev) | ICS_DMA0_E);
2049                 /* Must be 2 steps.  See PLX app note about "Starting a DMA transfer" */
2050                 RtdDma0Control(dev, PLX_DMA_EN_BIT);    /* enable DMA (clear INTR?) */
2051                 RtdDma0Control(dev, PLX_DMA_EN_BIT | PLX_DMA_START_BIT);        /*start DMA */
2052                 DPRINTK("rtd520: Using DMA0 transfers. plxInt %x RtdInt %x\n",
2053                         RtdPlxInterruptRead(dev), devpriv->intMask);
2054 #else /* USE_DMA */
2055                 RtdInterruptMask(dev, IRQM_ADC_ABOUT_CNT);
2056                 DPRINTK("rtd520: Transferring every 1/2 FIFO\n");
2057 #endif /* USE_DMA */
2058         }
2059
2060         /* BUG: start_src is ASSUMED to be TRIG_NOW */
2061         /* BUG? it seems like things are running before the "start" */
2062         RtdPacerStart(dev);     /* Start PACER */
2063         return 0;
2064 }
2065
2066 /*
2067   Stop a running data aquisition.
2068 */
2069 static int rtd_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
2070 {
2071         u16 status;
2072
2073         RtdPacerStopSource(dev, 0);     /* stop on SOFTWARE stop */
2074         RtdPacerStop(dev);      /* Stop PACER */
2075         RtdAdcConversionSource(dev, 0); /* software trigger only */
2076         RtdInterruptMask(dev, 0);
2077         devpriv->aiCount = 0;   /* stop and don't transfer any more */
2078 #ifdef USE_DMA
2079         if (devpriv->flags & DMA0_ACTIVE) {
2080                 RtdPlxInterruptWrite(dev,       /* disable any more interrupts */
2081                         RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
2082                 abort_dma(dev, 0);
2083                 devpriv->flags &= ~DMA0_ACTIVE;
2084         }
2085 #endif /* USE_DMA */
2086         status = RtdInterruptStatus(dev);
2087         DPRINTK("rtd520: Acquisition canceled. %ld ints, intStat=%x, overStat=%x\n", devpriv->intCount, status, 0xffff & RtdInterruptOverrunStatus(dev));
2088         return 0;
2089 }
2090
2091 /*
2092   Given a desired period and the clock period (both in ns),
2093   return the proper counter value (divider-1).
2094   Sets the original period to be the true value.
2095   Note: you have to check if the value is larger than the counter range!
2096 */
2097 static int rtd_ns_to_timer_base(unsigned int *nanosec,  /* desired period (in ns) */
2098         int round_mode, int base)
2099 {                               /* clock period (in ns) */
2100         int divider;
2101
2102         switch (round_mode) {
2103         case TRIG_ROUND_NEAREST:
2104         default:
2105                 divider = (*nanosec + base / 2) / base;
2106                 break;
2107         case TRIG_ROUND_DOWN:
2108                 divider = (*nanosec) / base;
2109                 break;
2110         case TRIG_ROUND_UP:
2111                 divider = (*nanosec + base - 1) / base;
2112                 break;
2113         }
2114         if (divider < 2)
2115                 divider = 2;    /* min is divide by 2 */
2116
2117         /* Note: we don't check for max, because different timers
2118            have different ranges */
2119
2120         *nanosec = base * divider;
2121         return divider - 1;     /* countdown is divisor+1 */
2122 }
2123
2124 /*
2125   Given a desired period (in ns),
2126   return the proper counter value (divider-1) for the internal clock.
2127   Sets the original period to be the true value.
2128 */
2129 static int rtd_ns_to_timer(unsigned int *ns, int round_mode)
2130 {
2131         return rtd_ns_to_timer_base(ns, round_mode, RTD_CLOCK_BASE);
2132 }
2133
2134 /*
2135   Output one (or more) analog values to a single port as fast as possible.
2136 */
2137 static int rtd_ao_winsn(struct comedi_device *dev,
2138         struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data)
2139 {
2140         int i;
2141         int chan = CR_CHAN(insn->chanspec);
2142         int range = CR_RANGE(insn->chanspec);
2143
2144         /* Configure the output range (table index matches the range values) */
2145         RtdDacRange(dev, chan, range);
2146
2147         /* Writing a list of values to an AO channel is probably not
2148          * very useful, but that's how the interface is defined. */
2149         for (i = 0; i < insn->n; ++i) {
2150                 int val = data[i] << 3;
2151                 int stat = 0;   /* initialize to avoid bogus warning */
2152                 int ii;
2153
2154                 /* VERIFY: comedi range and offset conversions */
2155
2156                 if ((range > 1) /* bipolar */
2157                         && (data[i] < 2048)) {
2158                         /* offset and sign extend */
2159                         val = (((int)data[i]) - 2048) << 3;
2160                 } else {        /* unipolor */
2161                         val = data[i] << 3;
2162                 }
2163
2164                 DPRINTK("comedi: rtd520 DAC chan=%d range=%d writing %d as 0x%x\n", chan, range, data[i], val);
2165
2166                 /* a typical programming sequence */
2167                 RtdDacFifoPut(dev, chan, val);  /* put the value in */
2168                 RtdDacUpdate(dev, chan);        /* trigger the conversion */
2169
2170                 devpriv->aoValue[chan] = data[i];       /* save for read back */
2171
2172                 for (ii = 0; ii < RTD_DAC_TIMEOUT; ++ii) {
2173                         stat = RtdFifoStatus(dev);
2174                         /* 1 -> not empty */
2175                         if (stat & ((0 == chan) ? FS_DAC1_NOT_EMPTY :
2176                                         FS_DAC2_NOT_EMPTY))
2177                                 break;
2178                         WAIT_QUIETLY;
2179                 }
2180                 if (ii >= RTD_DAC_TIMEOUT) {
2181                         DPRINTK("rtd520: Error: DAC never finished! FifoStatus=0x%x\n", stat ^ 0x6666);
2182                         return -ETIMEDOUT;
2183                 }
2184         }
2185
2186         /* return the number of samples read/written */
2187         return i;
2188 }
2189
2190 /* AO subdevices should have a read insn as well as a write insn.
2191  * Usually this means copying a value stored in devpriv. */
2192 static int rtd_ao_rinsn(struct comedi_device *dev,
2193         struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data)
2194 {
2195         int i;
2196         int chan = CR_CHAN(insn->chanspec);
2197
2198         for (i = 0; i < insn->n; i++) {
2199                 data[i] = devpriv->aoValue[chan];
2200         }
2201
2202         return i;
2203 }
2204
2205 /*
2206    Write a masked set of bits and the read back the port.
2207    We track what the bits should be (i.e. we don't read the port first).
2208
2209    DIO devices are slightly special.  Although it is possible to
2210  * implement the insn_read/insn_write interface, it is much more
2211  * useful to applications if you implement the insn_bits interface.
2212  * This allows packed reading/writing of the DIO channels.  The
2213  * comedi core can convert between insn_bits and insn_read/write
2214  */
2215 static int rtd_dio_insn_bits(struct comedi_device *dev,
2216         struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data)
2217 {
2218         if (insn->n != 2)
2219                 return -EINVAL;
2220
2221         /* The insn data is a mask in data[0] and the new data
2222          * in data[1], each channel cooresponding to a bit. */
2223         if (data[0]) {
2224                 s->state &= ~data[0];
2225                 s->state |= data[0] & data[1];
2226
2227                 /* Write out the new digital output lines */
2228                 RtdDio0Write(dev, s->state);
2229         }
2230         /* on return, data[1] contains the value of the digital
2231          * input lines. */
2232         data[1] = RtdDio0Read(dev);
2233
2234         /*DPRINTK("rtd520:port_0 wrote: 0x%x read: 0x%x\n", s->state, data[1]); */
2235
2236         return 2;
2237 }
2238
2239 /*
2240   Configure one bit on a IO port as Input or Output (hence the name :-).
2241 */
2242 static int rtd_dio_insn_config(struct comedi_device *dev,
2243         struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data)
2244 {
2245         int chan = CR_CHAN(insn->chanspec);
2246
2247         /* The input or output configuration of each digital line is
2248          * configured by a special insn_config instruction.  chanspec
2249          * contains the channel to be changed, and data[0] contains the
2250          * value COMEDI_INPUT or COMEDI_OUTPUT. */
2251         switch (data[0]) {
2252         case INSN_CONFIG_DIO_OUTPUT:
2253                 s->io_bits |= 1 << chan;        /* 1 means Out */
2254                 break;
2255         case INSN_CONFIG_DIO_INPUT:
2256                 s->io_bits &= ~(1 << chan);
2257                 break;
2258         case INSN_CONFIG_DIO_QUERY:
2259                 data[1] =
2260                         (s->
2261                         io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
2262                 return insn->n;
2263                 break;
2264         default:
2265                 return -EINVAL;
2266         }
2267
2268         DPRINTK("rtd520: port_0_direction=0x%x (1 means out)\n", s->io_bits);
2269         /* TODO support digital match interrupts and strobes */
2270         RtdDioStatusWrite(dev, 0x01);   /* make Dio0Ctrl point to direction */
2271         RtdDio0CtrlWrite(dev, s->io_bits);      /* set direction 1 means Out */
2272         RtdDioStatusWrite(dev, 0);      /* make Dio0Ctrl clear interrupts */
2273
2274         /* port1 can only be all input or all output */
2275
2276         /* there are also 2 user input lines and 2 user output lines */
2277
2278         return 1;
2279 }
2280
2281 /*
2282  * A convenient macro that defines init_module() and cleanup_module(),
2283  * as necessary.
2284  */
2285 COMEDI_PCI_INITCLEANUP(rtd520Driver, rtd520_pci_table);