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