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