drivers/staging/comedi/drivers/amplc_pci224.c

   1 /*
   2     comedi/drivers/amplc_pci224.c
   3     Driver for Amplicon PCI224 and PCI234 AO boards.
   4
   5     Copyright (C) 2005 MEV Ltd. <http://www.mev.co.uk/>
   6
   7     COMEDI - Linux Control and Measurement Device Interface
   8     Copyright (C) 1998,2000 David A. Schleef <ds@schleef.org>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24 */
  25 /*
  26 Driver: amplc_pci224
  27 Description: Amplicon PCI224, PCI234
  28 Author: Ian Abbott <abbotti@mev.co.uk>
  29 Devices: [Amplicon] PCI224 (amplc_pci224 or pci224),
  30   PCI234 (amplc_pci224 or pci234)
  31 Updated: Wed, 22 Oct 2008 12:25:08 +0100
  32 Status: works, but see caveats
  33
  34 Supports:
  35
  36   - ao_insn read/write
  37   - ao_do_cmd mode with the following sources:
  38
  39     - start_src         TRIG_INT        TRIG_EXT
  40     - scan_begin_src    TRIG_TIMER      TRIG_EXT
  41     - convert_src       TRIG_NOW
  42     - scan_end_src      TRIG_COUNT
  43     - stop_src          TRIG_COUNT      TRIG_EXT        TRIG_NONE
  44
  45     The channel list must contain at least one channel with no repeated
  46     channels.  The scan end count must equal the number of channels in
  47     the channel list.
  48
  49     There is only one external trigger source so only one of start_src,
  50     scan_begin_src or stop_src may use TRIG_EXT.
  51
  52 Configuration options - PCI224:
  53   [0] - PCI bus of device (optional).
  54   [1] - PCI slot of device (optional).
  55           If bus/slot is not specified, the first available PCI device
  56           will be used.
  57   [2] - Select available ranges according to jumper LK1.  All channels
  58         are set to the same range:
  59         0=Jumper position 1-2 (factory default), 4 software-selectable
  60           internal voltage references, giving 4 bipolar and 4 unipolar
  61           ranges:
  62             [-10V,+10V], [-5V,+5V], [-2.5V,+2.5V], [-1.25V,+1.25V],
  63             [0,+10V], [0,+5V], [0,+2.5V], [0,1.25V].
  64         1=Jumper position 2-3, 1 external voltage reference, giving
  65           1 bipolar and 1 unipolar range:
  66             [-Vext,+Vext], [0,+Vext].
  67
  68 Configuration options - PCI234:
  69   [0] - PCI bus of device (optional).
  70   [1] - PCI slot of device (optional).
  71           If bus/slot is not specified, the first available PCI device
  72           will be used.
  73   [2] - Select internal or external voltage reference according to
  74         jumper LK1.  This affects all channels:
  75         0=Jumper position 1-2 (factory default), Vref=5V internal.
  76         1=Jumper position 2-3, Vref=Vext external.
  77   [3] - Select channel 0 range according to jumper LK2:
  78         0=Jumper position 2-3 (factory default), range [-2*Vref,+2*Vref]
  79           (10V bipolar when options[2]=0).
  80         1=Jumper position 1-2, range [-Vref,+Vref]
  81           (5V bipolar when options[2]=0).
  82   [4] - Select channel 1 range according to jumper LK3: cf. options[3].
  83   [5] - Select channel 2 range according to jumper LK4: cf. options[3].
  84   [6] - Select channel 3 range according to jumper LK5: cf. options[3].
  85
  86 Passing a zero for an option is the same as leaving it unspecified.
  87
  88 Caveats:
  89
  90   1) All channels on the PCI224 share the same range.  Any change to the
  91      range as a result of insn_write or a streaming command will affect
  92      the output voltages of all channels, including those not specified
  93      by the instruction or command.
  94
  95   2) For the analog output command,  the first scan may be triggered
  96      falsely at the start of acquisition.  This occurs when the DAC scan
  97      trigger source is switched from 'none' to 'timer' (scan_begin_src =
  98      TRIG_TIMER) or 'external' (scan_begin_src == TRIG_EXT) at the start
  99      of acquisition and the trigger source is at logic level 1 at the
 100      time of the switch.  This is very likely for TRIG_TIMER.  For
 101      TRIG_EXT, it depends on the state of the external line and whether
 102      the CR_INVERT flag has been set.  The remaining scans are triggered
 103      correctly.
 104 */
 105
 106 #include <linux/interrupt.h>
 107 #include <linux/slab.h>
 108
 109 #include "../comedidev.h"
 110
 111 #include "comedi_pci.h"
 112
 113 #include "comedi_fc.h"
 114 #include "8253.h"
 115
 116 #define DRIVER_NAME     "amplc_pci224"
 117
 118 /*
 119  * PCI IDs.
 120  */
 121 #define PCI_VENDOR_ID_AMPLICON 0x14dc
 122 #define PCI_DEVICE_ID_AMPLICON_PCI224 0x0007
 123 #define PCI_DEVICE_ID_AMPLICON_PCI234 0x0008
 124 #define PCI_DEVICE_ID_INVALID 0xffff
 125
 126 /*
 127  * PCI224/234 i/o space 1 (PCIBAR2) registers.
 128  */
 129 #define PCI224_IO1_SIZE 0x20    /* Size of i/o space 1 (8-bit registers) */
 130 #define PCI224_Z2_CT0   0x14    /* 82C54 counter/timer 0 */
 131 #define PCI224_Z2_CT1   0x15    /* 82C54 counter/timer 1 */
 132 #define PCI224_Z2_CT2   0x16    /* 82C54 counter/timer 2 */
 133 #define PCI224_Z2_CTC   0x17    /* 82C54 counter/timer control word */
 134 #define PCI224_ZCLK_SCE 0x1A    /* Group Z Clock Configuration Register */
 135 #define PCI224_ZGAT_SCE 0x1D    /* Group Z Gate Configuration Register */
 136 #define PCI224_INT_SCE  0x1E    /* ISR Interrupt source mask register */
 137                                 /* /Interrupt status */
 138
 139 /*
 140  * PCI224/234 i/o space 2 (PCIBAR3) 16-bit registers.
 141  */
 142 #define PCI224_IO2_SIZE 0x10    /* Size of i/o space 2 (16-bit registers). */
 143 #define PCI224_DACDATA  0x00    /* (w-o) DAC FIFO data. */
 144 #define PCI224_SOFTTRIG 0x00    /* (r-o) DAC software scan trigger. */
 145 #define PCI224_DACCON   0x02    /* (r/w) DAC status/configuration. */
 146 #define PCI224_FIFOSIZ  0x04    /* (w-o) FIFO size for wraparound mode. */
 147 #define PCI224_DACCEN   0x06    /* (w-o) DAC channel enable register. */
 148
 149 /*
 150  * DACCON values.
 151  */
 152 /* (r/w) Scan trigger. */
 153 #define PCI224_DACCON_TRIG_MASK         (7 << 0)
 154 #define PCI224_DACCON_TRIG_NONE         (0 << 0)        /* none */
 155 #define PCI224_DACCON_TRIG_SW           (1 << 0)        /* software trig */
 156 #define PCI224_DACCON_TRIG_EXTP         (2 << 0)        /* ext +ve edge */
 157 #define PCI224_DACCON_TRIG_EXTN         (3 << 0)        /* ext -ve edge */
 158 #define PCI224_DACCON_TRIG_Z2CT0        (4 << 0)        /* Z2 CT0 out */
 159 #define PCI224_DACCON_TRIG_Z2CT1        (5 << 0)        /* Z2 CT1 out */
 160 #define PCI224_DACCON_TRIG_Z2CT2        (6 << 0)        /* Z2 CT2 out */
 161 /* (r/w) Polarity (PCI224 only, PCI234 always bipolar!). */
 162 #define PCI224_DACCON_POLAR_MASK        (1 << 3)
 163 #define PCI224_DACCON_POLAR_UNI         (0 << 3)        /* range [0,Vref] */
 164 #define PCI224_DACCON_POLAR_BI          (1 << 3)        /* range [-Vref,Vref] */
 165 /* (r/w) Internal Vref (PCI224 only, when LK1 in position 1-2). */
 166 #define PCI224_DACCON_VREF_MASK         (3 << 4)
 167 #define PCI224_DACCON_VREF_1_25         (0 << 4)        /* Vref = 1.25V */
 168 #define PCI224_DACCON_VREF_2_5          (1 << 4)        /* Vref = 2.5V */
 169 #define PCI224_DACCON_VREF_5            (2 << 4)        /* Vref = 5V */
 170 #define PCI224_DACCON_VREF_10           (3 << 4)        /* Vref = 10V */
 171 /* (r/w) Wraparound mode enable (to play back stored waveform). */
 172 #define PCI224_DACCON_FIFOWRAP          (1 << 7)
 173 /* (r/w) FIFO enable.  It MUST be set! */
 174 #define PCI224_DACCON_FIFOENAB          (1 << 8)
 175 /* (r/w) FIFO interrupt trigger level (most values are not very useful). */
 176 #define PCI224_DACCON_FIFOINTR_MASK     (7 << 9)
 177 #define PCI224_DACCON_FIFOINTR_EMPTY    (0 << 9)        /* when empty */
 178 #define PCI224_DACCON_FIFOINTR_NEMPTY   (1 << 9)        /* when not empty */
 179 #define PCI224_DACCON_FIFOINTR_NHALF    (2 << 9)        /* when not half full */
 180 #define PCI224_DACCON_FIFOINTR_HALF     (3 << 9)        /* when half full */
 181 #define PCI224_DACCON_FIFOINTR_NFULL    (4 << 9)        /* when not full */
 182 #define PCI224_DACCON_FIFOINTR_FULL     (5 << 9)        /* when full */
 183 /* (r-o) FIFO fill level. */
 184 #define PCI224_DACCON_FIFOFL_MASK       (7 << 12)
 185 #define PCI224_DACCON_FIFOFL_EMPTY      (1 << 12)       /* 0 */
 186 #define PCI224_DACCON_FIFOFL_ONETOHALF  (0 << 12)       /* [1,2048] */
 187 #define PCI224_DACCON_FIFOFL_HALFTOFULL (4 << 12)       /* [2049,4095] */
 188 #define PCI224_DACCON_FIFOFL_FULL       (6 << 12)       /* 4096 */
 189 /* (r-o) DAC busy flag. */
 190 #define PCI224_DACCON_BUSY              (1 << 15)
 191 /* (w-o) FIFO reset. */
 192 #define PCI224_DACCON_FIFORESET         (1 << 12)
 193 /* (w-o) Global reset (not sure what it does). */
 194 #define PCI224_DACCON_GLOBALRESET       (1 << 13)
 195
 196 /*
 197  * DAC FIFO size.
 198  */
 199 #define PCI224_FIFO_SIZE        4096
 200
 201 /*
 202  * DAC FIFO guaranteed minimum room available, depending on reported fill level.
 203  * The maximum room available depends on the reported fill level and how much
 204  * has been written!
 205  */
 206 #define PCI224_FIFO_ROOM_EMPTY          PCI224_FIFO_SIZE
 207 #define PCI224_FIFO_ROOM_ONETOHALF      (PCI224_FIFO_SIZE / 2)
 208 #define PCI224_FIFO_ROOM_HALFTOFULL     1
 209 #define PCI224_FIFO_ROOM_FULL           0
 210
 211 /*
 212  * Counter/timer clock input configuration sources.
 213  */
 214 #define CLK_CLK         0       /* reserved (channel-specific clock) */
 215 #define CLK_10MHZ       1       /* internal 10 MHz clock */
 216 #define CLK_1MHZ        2       /* internal 1 MHz clock */
 217 #define CLK_100KHZ      3       /* internal 100 kHz clock */
 218 #define CLK_10KHZ       4       /* internal 10 kHz clock */
 219 #define CLK_1KHZ        5       /* internal 1 kHz clock */
 220 #define CLK_OUTNM1      6       /* output of channel-1 modulo total */
 221 #define CLK_EXT         7       /* external clock */
 222 /* Macro to construct clock input configuration register value. */
 223 #define CLK_CONFIG(chan, src)   ((((chan) & 3) << 3) | ((src) & 7))
 224 /* Timebases in ns. */
 225 #define TIMEBASE_10MHZ          100
 226 #define TIMEBASE_1MHZ           1000
 227 #define TIMEBASE_100KHZ         10000
 228 #define TIMEBASE_10KHZ          100000
 229 #define TIMEBASE_1KHZ           1000000
 230
 231 /*
 232  * Counter/timer gate input configuration sources.
 233  */
 234 #define GAT_VCC         0       /* VCC (i.e. enabled) */
 235 #define GAT_GND         1       /* GND (i.e. disabled) */
 236 #define GAT_EXT         2       /* reserved (external gate input) */
 237 #define GAT_NOUTNM2     3       /* inverted output of channel-2 modulo total */
 238 /* Macro to construct gate input configuration register value. */
 239 #define GAT_CONFIG(chan, src)   ((((chan) & 3) << 3) | ((src) & 7))
 240
 241 /*
 242  * Summary of CLK_OUTNM1 and GAT_NOUTNM2 connections for PCI224 and PCI234:
 243  *
 244  *              Channel's       Channel's
 245  *              clock input     gate input
 246  * Channel      CLK_OUTNM1      GAT_NOUTNM2
 247  * -------      ----------      -----------
 248  * Z2-CT0       Z2-CT2-OUT      /Z2-CT1-OUT
 249  * Z2-CT1       Z2-CT0-OUT      /Z2-CT2-OUT
 250  * Z2-CT2       Z2-CT1-OUT      /Z2-CT0-OUT
 251  */
 252
 253 /*
 254  * Interrupt enable/status bits
 255  */
 256 #define PCI224_INTR_EXT         0x01    /* rising edge on external input */
 257 #define PCI224_INTR_DAC         0x04    /* DAC (FIFO) interrupt */
 258 #define PCI224_INTR_Z2CT1       0x20    /* rising edge on Z2-CT1 output */
 259
 260 #define PCI224_INTR_EDGE_BITS   (PCI224_INTR_EXT | PCI224_INTR_Z2CT1)
 261 #define PCI224_INTR_LEVEL_BITS  PCI224_INTR_DACFIFO
 262
 263 /*
 264  * Handy macros.
 265  */
 266
 267 /* Combine old and new bits. */
 268 #define COMBINE(old, new, mask) (((old) & ~(mask)) | ((new) & (mask)))
 269
 270 /* A generic null function pointer value.  */
 271 #define NULLFUNC        0
 272
 273 /* Current CPU.  XXX should this be hard_smp_processor_id()? */
 274 #define THISCPU         smp_processor_id()
 275
 276 /* State bits for use with atomic bit operations. */
 277 #define AO_CMD_STARTED  0
 278
 279 /*
 280  * Range tables.
 281  */
 282
 283 /* The software selectable internal ranges for PCI224 (option[2] == 0). */
 284 static const struct comedi_lrange range_pci224_internal = {
 285         8,
 286         {
 287          BIP_RANGE(10),
 288          BIP_RANGE(5),
 289          BIP_RANGE(2.5),
 290          BIP_RANGE(1.25),
 291          UNI_RANGE(10),
 292          UNI_RANGE(5),
 293          UNI_RANGE(2.5),
 294          UNI_RANGE(1.25),
 295          }
 296 };
 297
 298 static const unsigned short hwrange_pci224_internal[8] = {
 299         PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_10,
 300         PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_5,
 301         PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_2_5,
 302         PCI224_DACCON_POLAR_BI | PCI224_DACCON_VREF_1_25,
 303         PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_10,
 304         PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_5,
 305         PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_2_5,
 306         PCI224_DACCON_POLAR_UNI | PCI224_DACCON_VREF_1_25,
 307 };
 308
 309 /* The software selectable external ranges for PCI224 (option[2] == 1). */
 310 static const struct comedi_lrange range_pci224_external = {
 311         2,
 312         {
 313          RANGE_ext(-1, 1),      /* bipolar [-Vref,+Vref] */
 314          RANGE_ext(0, 1),       /* unipolar [0,+Vref] */
 315          }
 316 };
 317
 318 static const unsigned short hwrange_pci224_external[2] = {
 319         PCI224_DACCON_POLAR_BI,
 320         PCI224_DACCON_POLAR_UNI,
 321 };
 322
 323 /* The hardware selectable Vref*2 external range for PCI234
 324  * (option[2] == 1, option[3+n] == 0). */
 325 static const struct comedi_lrange range_pci234_ext2 = {
 326         1,
 327         {
 328          RANGE_ext(-2, 2),
 329          }
 330 };
 331
 332 /* The hardware selectable Vref external range for PCI234
 333  * (option[2] == 1, option[3+n] == 1). */
 334 static const struct comedi_lrange range_pci234_ext = {
 335         1,
 336         {
 337          RANGE_ext(-1, 1),
 338          }
 339 };
 340
 341 /* This serves for all the PCI234 ranges. */
 342 static const unsigned short hwrange_pci234[1] = {
 343         PCI224_DACCON_POLAR_BI, /* bipolar - hardware ignores it! */
 344 };
 345
 346 /*
 347  * Board descriptions.
 348  */
 349
 350 enum pci224_model { any_model, pci224_model, pci234_model };
 351
 352 struct pci224_board {
 353         const char *name;
 354         unsigned short devid;
 355         enum pci224_model model;
 356         unsigned int ao_chans;
 357         unsigned int ao_bits;
 358 };
 359
 360 static const struct pci224_board pci224_boards[] = {
 361         {
 362          .name = "pci224",
 363          .devid = PCI_DEVICE_ID_AMPLICON_PCI224,
 364          .model = pci224_model,
 365          .ao_chans = 16,
 366          .ao_bits = 12,
 367          },
 368         {
 369          .name = "pci234",
 370          .devid = PCI_DEVICE_ID_AMPLICON_PCI234,
 371          .model = pci234_model,
 372          .ao_chans = 4,
 373          .ao_bits = 16,
 374          },
 375         {
 376          .name = DRIVER_NAME,
 377          .devid = PCI_DEVICE_ID_INVALID,
 378          .model = any_model,    /* wildcard */
 379          },
 380 };
 381
 382 /*
 383  * PCI driver table.
 384  */
 385
 386 static DEFINE_PCI_DEVICE_TABLE(pci224_pci_table) = {
 387         {
 388         PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI224,
 389                     PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
 390         PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI234,
 391                     PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
 392         0}
 393 };
 394
 395 MODULE_DEVICE_TABLE(pci, pci224_pci_table);
 396
 397 /*
 398  * Useful for shorthand access to the particular board structure
 399  */
 400 #define thisboard ((struct pci224_board *)dev->board_ptr)
 401
 402 /* this structure is for data unique to this hardware driver.  If
 403    several hardware drivers keep similar information in this structure,
 404    feel free to suggest moving the variable to the struct comedi_device struct.  */
 405 struct pci224_private {
 406         struct pci_dev *pci_dev;        /* PCI device */
 407         const unsigned short *hwrange;
 408         unsigned long iobase1;
 409         unsigned long state;
 410         spinlock_t ao_spinlock;
 411         unsigned int *ao_readback;
 412         short *ao_scan_vals;
 413         unsigned char *ao_scan_order;
 414         int intr_cpuid;
 415         short intr_running;
 416         unsigned short daccon;
 417         unsigned int cached_div1;
 418         unsigned int cached_div2;
 419         unsigned int ao_stop_count;
 420         short ao_stop_continuous;
 421         unsigned short ao_enab; /* max 16 channels so 'short' will do */
 422         unsigned char intsce;
 423 };
 424
 425 #define devpriv ((struct pci224_private *)dev->private)
 426
 427 /*
 428  * The struct comedi_driver structure tells the Comedi core module
 429  * which functions to call to configure/deconfigure (attach/detach)
 430  * the board, and also about the kernel module that contains
 431  * the device code.
 432  */
 433 static int pci224_attach(struct comedi_device *dev,
 434                          struct comedi_devconfig *it);
 435 static int pci224_detach(struct comedi_device *dev);
 436 static struct comedi_driver driver_amplc_pci224 = {
 437         .driver_name = DRIVER_NAME,
 438         .module = THIS_MODULE,
 439         .attach = pci224_attach,
 440         .detach = pci224_detach,
 441         .board_name = &pci224_boards[0].name,
 442         .offset = sizeof(struct pci224_board),
 443         .num_names = ARRAY_SIZE(pci224_boards),
 444 };
 445
 446 static int __devinit driver_amplc_pci224_pci_probe(struct pci_dev *dev,
 447                                                    const struct pci_device_id
 448                                                    *ent)
 449 {
 450         return comedi_pci_auto_config(dev, driver_amplc_pci224.driver_name);
 451 }
 452
 453 static void __devexit driver_amplc_pci224_pci_remove(struct pci_dev *dev)
 454 {
 455         comedi_pci_auto_unconfig(dev);
 456 }
 457
 458 static struct pci_driver driver_amplc_pci224_pci_driver = {
 459         .id_table = pci224_pci_table,
 460         .probe = &driver_amplc_pci224_pci_probe,
 461         .remove = __devexit_p(&driver_amplc_pci224_pci_remove)
 462 };
 463
 464 static int __init driver_amplc_pci224_init_module(void)
 465 {
 466         int retval;
 467
 468         retval = comedi_driver_register(&driver_amplc_pci224);
 469         if (retval < 0)
 470                 return retval;
 471
 472         driver_amplc_pci224_pci_driver.name =
 473             (char *)driver_amplc_pci224.driver_name;
 474         return pci_register_driver(&driver_amplc_pci224_pci_driver);
 475 }
 476
 477 static void __exit driver_amplc_pci224_cleanup_module(void)
 478 {
 479         pci_unregister_driver(&driver_amplc_pci224_pci_driver);
 480         comedi_driver_unregister(&driver_amplc_pci224);
 481 }
 482
 483 module_init(driver_amplc_pci224_init_module);
 484 module_exit(driver_amplc_pci224_cleanup_module);
 485
 486 /*
 487  * Called from the 'insn_write' function to perform a single write.
 488  */
 489 static void
 490 pci224_ao_set_data(struct comedi_device *dev, int chan, int range,
 491                    unsigned int data)
 492 {
 493         unsigned short mangled;
 494
 495         /* Store unmangled data for readback. */
 496         devpriv->ao_readback[chan] = data;
 497         /* Enable the channel. */
 498         outw(1 << chan, dev->iobase + PCI224_DACCEN);
 499         /* Set range and reset FIFO. */
 500         devpriv->daccon = COMBINE(devpriv->daccon, devpriv->hwrange[range],
 501                                   (PCI224_DACCON_POLAR_MASK |
 502                                    PCI224_DACCON_VREF_MASK));
 503         outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
 504              dev->iobase + PCI224_DACCON);
 505         /*
 506          * Mangle the data.  The hardware expects:
 507          * - bipolar: 16-bit 2's complement
 508          * - unipolar: 16-bit unsigned
 509          */
 510         mangled = (unsigned short)data << (16 - thisboard->ao_bits);
 511         if ((devpriv->daccon & PCI224_DACCON_POLAR_MASK) ==
 512             PCI224_DACCON_POLAR_BI) {
 513                 mangled ^= 0x8000;
 514         }
 515         /* Write mangled data to the FIFO. */
 516         outw(mangled, dev->iobase + PCI224_DACDATA);
 517         /* Trigger the conversion. */
 518         inw(dev->iobase + PCI224_SOFTTRIG);
 519 }
 520
 521 /*
 522  * 'insn_write' function for AO subdevice.
 523  */
 524 static int
 525 pci224_ao_insn_write(struct comedi_device *dev, struct comedi_subdevice *s,
 526                      struct comedi_insn *insn, unsigned int *data)
 527 {
 528         int i;
 529         int chan, range;
 530
 531         /* Unpack channel and range. */
 532         chan = CR_CHAN(insn->chanspec);
 533         range = CR_RANGE(insn->chanspec);
 534
 535         /* Writing a list of values to an AO channel is probably not
 536          * very useful, but that's how the interface is defined. */
 537         for (i = 0; i < insn->n; i++)
 538                 pci224_ao_set_data(dev, chan, range, data[i]);
 539
 540         return i;
 541 }
 542
 543 /*
 544  * 'insn_read' function for AO subdevice.
 545  *
 546  * N.B. The value read will not be valid if the DAC channel has
 547  * never been written successfully since the device was attached
 548  * or since the channel has been used by an AO streaming write
 549  * command.
 550  */
 551 static int
 552 pci224_ao_insn_read(struct comedi_device *dev, struct comedi_subdevice *s,
 553                     struct comedi_insn *insn, unsigned int *data)
 554 {
 555         int i;
 556         int chan;
 557
 558         chan = CR_CHAN(insn->chanspec);
 559
 560         for (i = 0; i < insn->n; i++)
 561                 data[i] = devpriv->ao_readback[chan];
 562
 563
 564         return i;
 565 }
 566
 567 /*
 568  * Just a wrapper for the inline function 'i8253_cascade_ns_to_timer'.
 569  */
 570 static void
 571 pci224_cascade_ns_to_timer(int osc_base, unsigned int *d1, unsigned int *d2,
 572                            unsigned int *nanosec, int round_mode)
 573 {
 574         i8253_cascade_ns_to_timer(osc_base, d1, d2, nanosec, round_mode);
 575 }
 576
 577 /*
 578  * Kills a command running on the AO subdevice.
 579  */
 580 static void pci224_ao_stop(struct comedi_device *dev,
 581                            struct comedi_subdevice *s)
 582 {
 583         unsigned long flags;
 584
 585         if (!test_and_clear_bit(AO_CMD_STARTED, &devpriv->state))
 586                 return;
 587
 588
 589         spin_lock_irqsave(&devpriv->ao_spinlock, flags);
 590         /* Kill the interrupts. */
 591         devpriv->intsce = 0;
 592         outb(0, devpriv->iobase1 + PCI224_INT_SCE);
 593         /*
 594          * Interrupt routine may or may not be running.  We may or may not
 595          * have been called from the interrupt routine (directly or
 596          * indirectly via a comedi_events() callback routine).  It's highly
 597          * unlikely that we've been called from some other interrupt routine
 598          * but who knows what strange things coders get up to!
 599          *
 600          * If the interrupt routine is currently running, wait for it to
 601          * finish, unless we appear to have been called via the interrupt
 602          * routine.
 603          */
 604         while (devpriv->intr_running && devpriv->intr_cpuid != THISCPU) {
 605                 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
 606                 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
 607         }
 608         spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
 609         /* Reconfigure DAC for insn_write usage. */
 610         outw(0, dev->iobase + PCI224_DACCEN);   /* Disable channels. */
 611         devpriv->daccon = COMBINE(devpriv->daccon,
 612                                   PCI224_DACCON_TRIG_SW |
 613                                   PCI224_DACCON_FIFOINTR_EMPTY,
 614                                   PCI224_DACCON_TRIG_MASK |
 615                                   PCI224_DACCON_FIFOINTR_MASK);
 616         outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
 617              dev->iobase + PCI224_DACCON);
 618 }
 619
 620 /*
 621  * Handles start of acquisition for the AO subdevice.
 622  */
 623 static void pci224_ao_start(struct comedi_device *dev,
 624                             struct comedi_subdevice *s)
 625 {
 626         struct comedi_cmd *cmd = &s->async->cmd;
 627         unsigned long flags;
 628
 629         set_bit(AO_CMD_STARTED, &devpriv->state);
 630         if (!devpriv->ao_stop_continuous && devpriv->ao_stop_count == 0) {
 631                 /* An empty acquisition! */
 632                 pci224_ao_stop(dev, s);
 633                 s->async->events |= COMEDI_CB_EOA;
 634                 comedi_event(dev, s);
 635         } else {
 636                 /* Enable interrupts. */
 637                 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
 638                 if (cmd->stop_src == TRIG_EXT)
 639                         devpriv->intsce = PCI224_INTR_EXT | PCI224_INTR_DAC;
 640                 else
 641                         devpriv->intsce = PCI224_INTR_DAC;
 642
 643                 outb(devpriv->intsce, devpriv->iobase1 + PCI224_INT_SCE);
 644                 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
 645         }
 646 }
 647
 648 /*
 649  * Handles interrupts from the DAC FIFO.
 650  */
 651 static void pci224_ao_handle_fifo(struct comedi_device *dev,
 652                                   struct comedi_subdevice *s)
 653 {
 654         struct comedi_cmd *cmd = &s->async->cmd;
 655         unsigned int num_scans;
 656         unsigned int room;
 657         unsigned short dacstat;
 658         unsigned int i, n;
 659         unsigned int bytes_per_scan;
 660
 661         if (cmd->chanlist_len) {
 662                 bytes_per_scan = cmd->chanlist_len * sizeof(short);
 663         } else {
 664                 /* Shouldn't get here! */
 665                 bytes_per_scan = sizeof(short);
 666         }
 667         /* Determine number of scans available in buffer. */
 668         num_scans = comedi_buf_read_n_available(s->async) / bytes_per_scan;
 669         if (!devpriv->ao_stop_continuous) {
 670                 /* Fixed number of scans. */
 671                 if (num_scans > devpriv->ao_stop_count)
 672                         num_scans = devpriv->ao_stop_count;
 673
 674         }
 675
 676         /* Determine how much room is in the FIFO (in samples). */
 677         dacstat = inw(dev->iobase + PCI224_DACCON);
 678         switch (dacstat & PCI224_DACCON_FIFOFL_MASK) {
 679         case PCI224_DACCON_FIFOFL_EMPTY:
 680                 room = PCI224_FIFO_ROOM_EMPTY;
 681                 if (!devpriv->ao_stop_continuous && devpriv->ao_stop_count == 0) {
 682                         /* FIFO empty at end of counted acquisition. */
 683                         pci224_ao_stop(dev, s);
 684                         s->async->events |= COMEDI_CB_EOA;
 685                         comedi_event(dev, s);
 686                         return;
 687                 }
 688                 break;
 689         case PCI224_DACCON_FIFOFL_ONETOHALF:
 690                 room = PCI224_FIFO_ROOM_ONETOHALF;
 691                 break;
 692         case PCI224_DACCON_FIFOFL_HALFTOFULL:
 693                 room = PCI224_FIFO_ROOM_HALFTOFULL;
 694                 break;
 695         default:
 696                 room = PCI224_FIFO_ROOM_FULL;
 697                 break;
 698         }
 699         if (room >= PCI224_FIFO_ROOM_ONETOHALF) {
 700                 /* FIFO is less than half-full. */
 701                 if (num_scans == 0) {
 702                         /* Nothing left to put in the FIFO. */
 703                         pci224_ao_stop(dev, s);
 704                         s->async->events |= COMEDI_CB_OVERFLOW;
 705                         printk(KERN_ERR "comedi%d: "
 706                                "AO buffer underrun\n", dev->minor);
 707                 }
 708         }
 709         /* Determine how many new scans can be put in the FIFO. */
 710         if (cmd->chanlist_len)
 711                 room /= cmd->chanlist_len;
 712
 713         /* Determine how many scans to process. */
 714         if (num_scans > room)
 715                 num_scans = room;
 716
 717         /* Process scans. */
 718         for (n = 0; n < num_scans; n++) {
 719                 cfc_read_array_from_buffer(s, &devpriv->ao_scan_vals[0],
 720                                            bytes_per_scan);
 721                 for (i = 0; i < cmd->chanlist_len; i++) {
 722                         outw(devpriv->ao_scan_vals[devpriv->ao_scan_order[i]],
 723                              dev->iobase + PCI224_DACDATA);
 724                 }
 725         }
 726         if (!devpriv->ao_stop_continuous) {
 727                 devpriv->ao_stop_count -= num_scans;
 728                 if (devpriv->ao_stop_count == 0) {
 729                         /*
 730                          * Change FIFO interrupt trigger level to wait
 731                          * until FIFO is empty.
 732                          */
 733                         devpriv->daccon = COMBINE(devpriv->daccon,
 734                                                   PCI224_DACCON_FIFOINTR_EMPTY,
 735                                                   PCI224_DACCON_FIFOINTR_MASK);
 736                         outw(devpriv->daccon, dev->iobase + PCI224_DACCON);
 737                 }
 738         }
 739         if ((devpriv->daccon & PCI224_DACCON_TRIG_MASK) ==
 740             PCI224_DACCON_TRIG_NONE) {
 741                 unsigned short trig;
 742
 743                 /*
 744                  * This is the initial DAC FIFO interrupt at the
 745                  * start of the acquisition.  The DAC's scan trigger
 746                  * has been set to 'none' up until now.
 747                  *
 748                  * Now that data has been written to the FIFO, the
 749                  * DAC's scan trigger source can be set to the
 750                  * correct value.
 751                  *
 752                  * BUG: The first scan will be triggered immediately
 753                  * if the scan trigger source is at logic level 1.
 754                  */
 755                 if (cmd->scan_begin_src == TRIG_TIMER) {
 756                         trig = PCI224_DACCON_TRIG_Z2CT0;
 757                 } else {
 758                         /* cmd->scan_begin_src == TRIG_EXT */
 759                         if (cmd->scan_begin_arg & CR_INVERT)
 760                                 trig = PCI224_DACCON_TRIG_EXTN;
 761                         else
 762                                 trig = PCI224_DACCON_TRIG_EXTP;
 763
 764                 }
 765                 devpriv->daccon = COMBINE(devpriv->daccon, trig,
 766                                           PCI224_DACCON_TRIG_MASK);
 767                 outw(devpriv->daccon, dev->iobase + PCI224_DACCON);
 768         }
 769         if (s->async->events)
 770                 comedi_event(dev, s);
 771
 772 }
 773
 774 /*
 775  * Internal trigger function to start acquisition on AO subdevice.
 776  */
 777 static int
 778 pci224_ao_inttrig_start(struct comedi_device *dev, struct comedi_subdevice *s,
 779                         unsigned int trignum)
 780 {
 781         if (trignum != 0)
 782                 return -EINVAL;
 783
 784         s->async->inttrig = NULLFUNC;
 785         pci224_ao_start(dev, s);
 786
 787         return 1;
 788 }
 789
 790 #define MAX_SCAN_PERIOD         0xFFFFFFFFU
 791 #define MIN_SCAN_PERIOD         2500
 792 #define CONVERT_PERIOD          625
 793
 794 /*
 795  * 'do_cmdtest' function for AO subdevice.
 796  */
 797 static int
 798 pci224_ao_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
 799                   struct comedi_cmd *cmd)
 800 {
 801         int err = 0;
 802         unsigned int tmp;
 803
 804         /* Step 1: make sure trigger sources are trivially valid. */
 805
 806         tmp = cmd->start_src;
 807         cmd->start_src &= TRIG_INT | TRIG_EXT;
 808         if (!cmd->start_src || tmp != cmd->start_src)
 809                 err++;
 810
 811         tmp = cmd->scan_begin_src;
 812         cmd->scan_begin_src &= TRIG_EXT | TRIG_TIMER;
 813         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
 814                 err++;
 815
 816         tmp = cmd->convert_src;
 817         cmd->convert_src &= TRIG_NOW;
 818         if (!cmd->convert_src || tmp != cmd->convert_src)
 819                 err++;
 820
 821         tmp = cmd->scan_end_src;
 822         cmd->scan_end_src &= TRIG_COUNT;
 823         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
 824                 err++;
 825
 826         tmp = cmd->stop_src;
 827         cmd->stop_src &= TRIG_COUNT | TRIG_EXT | TRIG_NONE;
 828         if (!cmd->stop_src || tmp != cmd->stop_src)
 829                 err++;
 830
 831         if (err)
 832                 return 1;
 833
 834         /* Step 2: make sure trigger sources are unique and mutually
 835          * compatible. */
 836
 837         /* these tests are true if more than one _src bit is set */
 838         if ((cmd->start_src & (cmd->start_src - 1)) != 0)
 839                 err++;
 840         if ((cmd->scan_begin_src & (cmd->scan_begin_src - 1)) != 0)
 841                 err++;
 842         if ((cmd->convert_src & (cmd->convert_src - 1)) != 0)
 843                 err++;
 844         if ((cmd->scan_end_src & (cmd->scan_end_src - 1)) != 0)
 845                 err++;
 846         if ((cmd->stop_src & (cmd->stop_src - 1)) != 0)
 847                 err++;
 848
 849         /* There's only one external trigger signal (which makes these
 850          * tests easier).  Only one thing can use it. */
 851         tmp = 0;
 852         if (cmd->start_src & TRIG_EXT)
 853                 tmp++;
 854         if (cmd->scan_begin_src & TRIG_EXT)
 855                 tmp++;
 856         if (cmd->stop_src & TRIG_EXT)
 857                 tmp++;
 858         if (tmp > 1)
 859                 err++;
 860
 861         if (err)
 862                 return 2;
 863
 864         /* Step 3: make sure arguments are trivially compatible. */
 865
 866         switch (cmd->start_src) {
 867         case TRIG_INT:
 868                 if (cmd->start_arg != 0) {
 869                         cmd->start_arg = 0;
 870                         err++;
 871                 }
 872                 break;
 873         case TRIG_EXT:
 874                 /* Force to external trigger 0. */
 875                 if ((cmd->start_arg & ~CR_FLAGS_MASK) != 0) {
 876                         cmd->start_arg = COMBINE(cmd->start_arg, 0,
 877                                                  ~CR_FLAGS_MASK);
 878                         err++;
 879                 }
 880                 /* The only flag allowed is CR_EDGE, which is ignored. */
 881                 if ((cmd->start_arg & CR_FLAGS_MASK & ~CR_EDGE) != 0) {
 882                         cmd->start_arg = COMBINE(cmd->start_arg, 0,
 883                                                  CR_FLAGS_MASK & ~CR_EDGE);
 884                         err++;
 885                 }
 886                 break;
 887         }
 888
 889         switch (cmd->scan_begin_src) {
 890         case TRIG_TIMER:
 891                 if (cmd->scan_begin_arg > MAX_SCAN_PERIOD) {
 892                         cmd->scan_begin_arg = MAX_SCAN_PERIOD;
 893                         err++;
 894                 }
 895                 tmp = cmd->chanlist_len * CONVERT_PERIOD;
 896                 if (tmp < MIN_SCAN_PERIOD)
 897                         tmp = MIN_SCAN_PERIOD;
 898
 899                 if (cmd->scan_begin_arg < tmp) {
 900                         cmd->scan_begin_arg = tmp;
 901                         err++;
 902                 }
 903                 break;
 904         case TRIG_EXT:
 905                 /* Force to external trigger 0. */
 906                 if ((cmd->scan_begin_arg & ~CR_FLAGS_MASK) != 0) {
 907                         cmd->scan_begin_arg = COMBINE(cmd->scan_begin_arg, 0,
 908                                                       ~CR_FLAGS_MASK);
 909                         err++;
 910                 }
 911                 /* Only allow flags CR_EDGE and CR_INVERT.  Ignore CR_EDGE. */
 912                 if ((cmd->scan_begin_arg & CR_FLAGS_MASK &
 913                      ~(CR_EDGE | CR_INVERT)) != 0) {
 914                         cmd->scan_begin_arg = COMBINE(cmd->scan_begin_arg, 0,
 915                                                       CR_FLAGS_MASK & ~(CR_EDGE
 916                                                                         |
 917                                                                         CR_INVERT));
 918                         err++;
 919                 }
 920                 break;
 921         }
 922
 923         /* cmd->convert_src == TRIG_NOW */
 924         if (cmd->convert_arg != 0) {
 925                 cmd->convert_arg = 0;
 926                 err++;
 927         }
 928
 929         /* cmd->scan_end_arg == TRIG_COUNT */
 930         if (cmd->scan_end_arg != cmd->chanlist_len) {
 931                 cmd->scan_end_arg = cmd->chanlist_len;
 932                 err++;
 933         }
 934
 935         switch (cmd->stop_src) {
 936         case TRIG_COUNT:
 937                 /* Any count allowed. */
 938                 break;
 939         case TRIG_EXT:
 940                 /* Force to external trigger 0. */
 941                 if ((cmd->stop_arg & ~CR_FLAGS_MASK) != 0) {
 942                         cmd->stop_arg = COMBINE(cmd->stop_arg, 0,
 943                                                 ~CR_FLAGS_MASK);
 944                         err++;
 945                 }
 946                 /* The only flag allowed is CR_EDGE, which is ignored. */
 947                 if ((cmd->stop_arg & CR_FLAGS_MASK & ~CR_EDGE) != 0) {
 948                         cmd->stop_arg = COMBINE(cmd->stop_arg, 0,
 949                                                 CR_FLAGS_MASK & ~CR_EDGE);
 950                 }
 951                 break;
 952         case TRIG_NONE:
 953                 if (cmd->stop_arg != 0) {
 954                         cmd->stop_arg = 0;
 955                         err++;
 956                 }
 957                 break;
 958         }
 959
 960         if (err)
 961                 return 3;
 962
 963         /* Step 4: fix up any arguments. */
 964
 965         if (cmd->scan_begin_src == TRIG_TIMER) {
 966                 unsigned int div1, div2, round;
 967                 int round_mode = cmd->flags & TRIG_ROUND_MASK;
 968
 969                 tmp = cmd->scan_begin_arg;
 970                 /* Check whether to use a single timer. */
 971                 switch (round_mode) {
 972                 case TRIG_ROUND_NEAREST:
 973                 default:
 974                         round = TIMEBASE_10MHZ / 2;
 975                         break;
 976                 case TRIG_ROUND_DOWN:
 977                         round = 0;
 978                         break;
 979                 case TRIG_ROUND_UP:
 980                         round = TIMEBASE_10MHZ - 1;
 981                         break;
 982                 }
 983                 /* Be careful to avoid overflow! */
 984                 div2 = cmd->scan_begin_arg / TIMEBASE_10MHZ;
 985                 div2 += (round + cmd->scan_begin_arg % TIMEBASE_10MHZ) /
 986                     TIMEBASE_10MHZ;
 987                 if (div2 <= 0x10000) {
 988                         /* A single timer will suffice. */
 989                         if (div2 < 2)
 990                                 div2 = 2;
 991                         cmd->scan_begin_arg = div2 * TIMEBASE_10MHZ;
 992                         if (cmd->scan_begin_arg < div2 ||
 993                             cmd->scan_begin_arg < TIMEBASE_10MHZ) {
 994                                 /* Overflow! */
 995                                 cmd->scan_begin_arg = MAX_SCAN_PERIOD;
 996                         }
 997                 } else {
 998                         /* Use two timers. */
 999                         div1 = devpriv->cached_div1;
1000                         div2 = devpriv->cached_div2;
1001                         pci224_cascade_ns_to_timer(TIMEBASE_10MHZ, &div1, &div2,
1002                                                    &cmd->scan_begin_arg,
1003                                                    round_mode);
1004                         devpriv->cached_div1 = div1;
1005                         devpriv->cached_div2 = div2;
1006                 }
1007                 if (tmp != cmd->scan_begin_arg)
1008                         err++;
1009
1010         }
1011
1012         if (err)
1013                 return 4;
1014
1015         /* Step 5: check channel list. */
1016
1017         if (cmd->chanlist && (cmd->chanlist_len > 0)) {
1018                 unsigned int range;
1019                 enum { range_err = 1, dupchan_err = 2, };
1020                 unsigned errors;
1021                 unsigned int n;
1022                 unsigned int ch;
1023
1024                 /*
1025                  * Check all channels have the same range index.  Don't care
1026                  * about analogue reference, as we can't configure it.
1027                  *
1028                  * Check the list has no duplicate channels.
1029                  */
1030                 range = CR_RANGE(cmd->chanlist[0]);
1031                 errors = 0;
1032                 tmp = 0;
1033                 for (n = 0; n < cmd->chanlist_len; n++) {
1034                         ch = CR_CHAN(cmd->chanlist[n]);
1035                         if (tmp & (1U << ch))
1036                                 errors |= dupchan_err;
1037
1038                         tmp |= (1U << ch);
1039                         if (CR_RANGE(cmd->chanlist[n]) != range)
1040                                 errors |= range_err;
1041
1042                 }
1043                 if (errors) {
1044                         if (errors & dupchan_err) {
1045                                 DPRINTK("comedi%d: " DRIVER_NAME
1046                                         ": ao_cmdtest: "
1047                                         "entries in chanlist must contain no "
1048                                         "duplicate channels\n", dev->minor);
1049                         }
1050                         if (errors & range_err) {
1051                                 DPRINTK("comedi%d: " DRIVER_NAME
1052                                         ": ao_cmdtest: "
1053                                         "entries in chanlist must all have "
1054                                         "the same range index\n", dev->minor);
1055                         }
1056                         err++;
1057                 }
1058         }
1059
1060         if (err)
1061                 return 5;
1062
1063         return 0;
1064 }
1065
1066 /*
1067  * 'do_cmd' function for AO subdevice.
1068  */
1069 static int pci224_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1070 {
1071         struct comedi_cmd *cmd = &s->async->cmd;
1072         int range;
1073         unsigned int i, j;
1074         unsigned int ch;
1075         unsigned int rank;
1076         unsigned long flags;
1077
1078         /* Cannot handle null/empty chanlist. */
1079         if (cmd->chanlist == NULL || cmd->chanlist_len == 0)
1080                 return -EINVAL;
1081
1082
1083         /* Determine which channels are enabled and their load order.  */
1084         devpriv->ao_enab = 0;
1085
1086         for (i = 0; i < cmd->chanlist_len; i++) {
1087                 ch = CR_CHAN(cmd->chanlist[i]);
1088                 devpriv->ao_enab |= 1U << ch;
1089                 rank = 0;
1090                 for (j = 0; j < cmd->chanlist_len; j++) {
1091                         if (CR_CHAN(cmd->chanlist[j]) < ch)
1092                                 rank++;
1093
1094                 }
1095                 devpriv->ao_scan_order[rank] = i;
1096         }
1097
1098         /* Set enabled channels. */
1099         outw(devpriv->ao_enab, dev->iobase + PCI224_DACCEN);
1100
1101         /* Determine range and polarity.  All channels the same.  */
1102         range = CR_RANGE(cmd->chanlist[0]);
1103
1104         /*
1105          * Set DAC range and polarity.
1106          * Set DAC scan trigger source to 'none'.
1107          * Set DAC FIFO interrupt trigger level to 'not half full'.
1108          * Reset DAC FIFO.
1109          *
1110          * N.B. DAC FIFO interrupts are currently disabled.
1111          */
1112         devpriv->daccon = COMBINE(devpriv->daccon,
1113                                   (devpriv->
1114                                    hwrange[range] | PCI224_DACCON_TRIG_NONE |
1115                                    PCI224_DACCON_FIFOINTR_NHALF),
1116                                   (PCI224_DACCON_POLAR_MASK |
1117                                    PCI224_DACCON_VREF_MASK |
1118                                    PCI224_DACCON_TRIG_MASK |
1119                                    PCI224_DACCON_FIFOINTR_MASK));
1120         outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
1121              dev->iobase + PCI224_DACCON);
1122
1123         if (cmd->scan_begin_src == TRIG_TIMER) {
1124                 unsigned int div1, div2, round;
1125                 unsigned int ns = cmd->scan_begin_arg;
1126                 int round_mode = cmd->flags & TRIG_ROUND_MASK;
1127
1128                 /* Check whether to use a single timer. */
1129                 switch (round_mode) {
1130                 case TRIG_ROUND_NEAREST:
1131                 default:
1132                         round = TIMEBASE_10MHZ / 2;
1133                         break;
1134                 case TRIG_ROUND_DOWN:
1135                         round = 0;
1136                         break;
1137                 case TRIG_ROUND_UP:
1138                         round = TIMEBASE_10MHZ - 1;
1139                         break;
1140                 }
1141                 /* Be careful to avoid overflow! */
1142                 div2 = cmd->scan_begin_arg / TIMEBASE_10MHZ;
1143                 div2 += (round + cmd->scan_begin_arg % TIMEBASE_10MHZ) /
1144                     TIMEBASE_10MHZ;
1145                 if (div2 <= 0x10000) {
1146                         /* A single timer will suffice. */
1147                         if (div2 < 2)
1148                                 div2 = 2;
1149                         div2 &= 0xffff;
1150                         div1 = 1;       /* Flag that single timer to be used. */
1151                 } else {
1152                         /* Use two timers. */
1153                         div1 = devpriv->cached_div1;
1154                         div2 = devpriv->cached_div2;
1155                         pci224_cascade_ns_to_timer(TIMEBASE_10MHZ, &div1, &div2,
1156                                                    &ns, round_mode);
1157                 }
1158
1159                 /*
1160                  * The output of timer Z2-0 will be used as the scan trigger
1161                  * source.
1162                  */
1163                 /* Make sure Z2-0 is gated on.  */
1164                 outb(GAT_CONFIG(0, GAT_VCC),
1165                      devpriv->iobase1 + PCI224_ZGAT_SCE);
1166                 if (div1 == 1) {
1167                         /* Not cascading.  Z2-0 needs 10 MHz clock. */
1168                         outb(CLK_CONFIG(0, CLK_10MHZ),
1169                              devpriv->iobase1 + PCI224_ZCLK_SCE);
1170                 } else {
1171                         /* Cascading with Z2-2. */
1172                         /* Make sure Z2-2 is gated on.  */
1173                         outb(GAT_CONFIG(2, GAT_VCC),
1174                              devpriv->iobase1 + PCI224_ZGAT_SCE);
1175                         /* Z2-2 needs 10 MHz clock. */
1176                         outb(CLK_CONFIG(2, CLK_10MHZ),
1177                              devpriv->iobase1 + PCI224_ZCLK_SCE);
1178                         /* Load Z2-2 mode (2) and counter (div1). */
1179                         i8254_load(devpriv->iobase1 + PCI224_Z2_CT0, 0,
1180                                    2, div1, 2);
1181                         /* Z2-0 is clocked from Z2-2's output. */
1182                         outb(CLK_CONFIG(0, CLK_OUTNM1),
1183                              devpriv->iobase1 + PCI224_ZCLK_SCE);
1184                 }
1185                 /* Load Z2-0 mode (2) and counter (div2). */
1186                 i8254_load(devpriv->iobase1 + PCI224_Z2_CT0, 0, 0, div2, 2);
1187         }
1188
1189         /*
1190          * Sort out end of acquisition.
1191          */
1192         switch (cmd->stop_src) {
1193         case TRIG_COUNT:
1194                 /* Fixed number of scans.  */
1195                 devpriv->ao_stop_continuous = 0;
1196                 devpriv->ao_stop_count = cmd->stop_arg;
1197                 break;
1198         default:
1199                 /* Continuous scans. */
1200                 devpriv->ao_stop_continuous = 1;
1201                 devpriv->ao_stop_count = 0;
1202                 break;
1203         }
1204
1205         /*
1206          * Sort out start of acquisition.
1207          */
1208         switch (cmd->start_src) {
1209         case TRIG_INT:
1210                 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1211                 s->async->inttrig = &pci224_ao_inttrig_start;
1212                 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1213                 break;
1214         case TRIG_EXT:
1215                 /* Enable external interrupt trigger to start acquisition. */
1216                 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1217                 devpriv->intsce |= PCI224_INTR_EXT;
1218                 outb(devpriv->intsce, devpriv->iobase1 + PCI224_INT_SCE);
1219                 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1220                 break;
1221         }
1222
1223         return 0;
1224 }
1225
1226 /*
1227  * 'cancel' function for AO subdevice.
1228  */
1229 static int pci224_ao_cancel(struct comedi_device *dev,
1230                             struct comedi_subdevice *s)
1231 {
1232         pci224_ao_stop(dev, s);
1233         return 0;
1234 }
1235
1236 /*
1237  * 'munge' data for AO command.
1238  */
1239 static void
1240 pci224_ao_munge(struct comedi_device *dev, struct comedi_subdevice *s,
1241                 void *data, unsigned int num_bytes, unsigned int chan_index)
1242 {
1243         struct comedi_async *async = s->async;
1244         short *array = data;
1245         unsigned int length = num_bytes / sizeof(*array);
1246         unsigned int offset;
1247         unsigned int shift;
1248         unsigned int i;
1249
1250         /* The hardware expects 16-bit numbers. */
1251         shift = 16 - thisboard->ao_bits;
1252         /* Channels will be all bipolar or all unipolar. */
1253         if ((devpriv->hwrange[CR_RANGE(async->cmd.chanlist[0])] &
1254              PCI224_DACCON_POLAR_MASK) == PCI224_DACCON_POLAR_UNI) {
1255                 /* Unipolar */
1256                 offset = 0;
1257         } else {
1258                 /* Bipolar */
1259                 offset = 32768;
1260         }
1261         /* Munge the data. */
1262         for (i = 0; i < length; i++)
1263                 array[i] = (array[i] << shift) - offset;
1264
1265 }
1266
1267 /*
1268  * Interrupt handler.
1269  */
1270 static irqreturn_t pci224_interrupt(int irq, void *d)
1271 {
1272         struct comedi_device *dev = d;
1273         struct comedi_subdevice *s = &dev->subdevices[0];
1274         struct comedi_cmd *cmd;
1275         unsigned char intstat, valid_intstat;
1276         unsigned char curenab;
1277         int retval = 0;
1278         unsigned long flags;
1279
1280         intstat = inb(devpriv->iobase1 + PCI224_INT_SCE) & 0x3F;
1281         if (intstat) {
1282                 retval = 1;
1283                 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1284                 valid_intstat = devpriv->intsce & intstat;
1285                 /* Temporarily disable interrupt sources. */
1286                 curenab = devpriv->intsce & ~intstat;
1287                 outb(curenab, devpriv->iobase1 + PCI224_INT_SCE);
1288                 devpriv->intr_running = 1;
1289                 devpriv->intr_cpuid = THISCPU;
1290                 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1291                 if (valid_intstat != 0) {
1292                         cmd = &s->async->cmd;
1293                         if (valid_intstat & PCI224_INTR_EXT) {
1294                                 devpriv->intsce &= ~PCI224_INTR_EXT;
1295                                 if (cmd->start_src == TRIG_EXT)
1296                                         pci224_ao_start(dev, s);
1297                                 else if (cmd->stop_src == TRIG_EXT)
1298                                         pci224_ao_stop(dev, s);
1299
1300                         }
1301                         if (valid_intstat & PCI224_INTR_DAC)
1302                                 pci224_ao_handle_fifo(dev, s);
1303
1304                 }
1305                 /* Reenable interrupt sources. */
1306                 spin_lock_irqsave(&devpriv->ao_spinlock, flags);
1307                 if (curenab != devpriv->intsce) {
1308                         outb(devpriv->intsce,
1309                              devpriv->iobase1 + PCI224_INT_SCE);
1310                 }
1311                 devpriv->intr_running = 0;
1312                 spin_unlock_irqrestore(&devpriv->ao_spinlock, flags);
1313         }
1314         return IRQ_RETVAL(retval);
1315 }
1316
1317 /*
1318  * This function looks for a PCI device matching the requested board name,
1319  * bus and slot.
1320  */
1321 static int
1322 pci224_find_pci(struct comedi_device *dev, int bus, int slot,
1323                 struct pci_dev **pci_dev_p)
1324 {
1325         struct pci_dev *pci_dev = NULL;
1326
1327         *pci_dev_p = NULL;
1328
1329         /* Look for matching PCI device. */
1330         for (pci_dev = pci_get_device(PCI_VENDOR_ID_AMPLICON, PCI_ANY_ID, NULL);
1331              pci_dev != NULL;
1332              pci_dev = pci_get_device(PCI_VENDOR_ID_AMPLICON, PCI_ANY_ID,
1333                                       pci_dev)) {
1334                 /* If bus/slot specified, check them. */
1335                 if (bus || slot) {
1336                         if (bus != pci_dev->bus->number
1337                             || slot != PCI_SLOT(pci_dev->devfn))
1338                                 continue;
1339                 }
1340                 if (thisboard->model == any_model) {
1341                         /* Match any supported model. */
1342                         int i;
1343
1344                         for (i = 0; i < ARRAY_SIZE(pci224_boards); i++) {
1345                                 if (pci_dev->device == pci224_boards[i].devid) {
1346                                         /* Change board_ptr to matched board. */
1347                                         dev->board_ptr = &pci224_boards[i];
1348                                         break;
1349                                 }
1350                         }
1351                         if (i == ARRAY_SIZE(pci224_boards))
1352                                 continue;
1353                 } else {
1354                         /* Match specific model name. */
1355                         if (thisboard->devid != pci_dev->device)
1356                                 continue;
1357                 }
1358
1359                 /* Found a match. */
1360                 *pci_dev_p = pci_dev;
1361                 return 0;
1362         }
1363         /* No match found. */
1364         if (bus || slot) {
1365                 printk(KERN_ERR "comedi%d: error! "
1366                        "no %s found at pci %02x:%02x!\n",
1367                        dev->minor, thisboard->name, bus, slot);
1368         } else {
1369                 printk(KERN_ERR "comedi%d: error! no %s found!\n",
1370                        dev->minor, thisboard->name);
1371         }
1372         return -EIO;
1373 }
1374
1375 /*
1376  * Attach is called by the Comedi core to configure the driver
1377  * for a particular board.  If you specified a board_name array
1378  * in the driver structure, dev->board_ptr contains that
1379  * address.
1380  */
1381 static int pci224_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1382 {
1383         struct comedi_subdevice *s;
1384         struct pci_dev *pci_dev;
1385         unsigned int irq;
1386         int bus = 0, slot = 0;
1387         unsigned n;
1388         int ret;
1389
1390         printk(KERN_DEBUG "comedi%d: %s: attach\n", dev->minor, DRIVER_NAME);
1391
1392         bus = it->options[0];
1393         slot = it->options[1];
1394         ret = alloc_private(dev, sizeof(struct pci224_private));
1395         if (ret < 0) {
1396                 printk(KERN_ERR "comedi%d: error! out of memory!\n",
1397                        dev->minor);
1398                 return ret;
1399         }
1400
1401         ret = pci224_find_pci(dev, bus, slot, &pci_dev);
1402         if (ret < 0)
1403                 return ret;
1404
1405         devpriv->pci_dev = pci_dev;
1406         ret = comedi_pci_enable(pci_dev, DRIVER_NAME);
1407         if (ret < 0) {
1408                 printk(KERN_ERR
1409                        "comedi%d: error! cannot enable PCI device "
1410                        "and request regions!\n", dev->minor);
1411                 return ret;
1412         }
1413         spin_lock_init(&devpriv->ao_spinlock);
1414
1415         devpriv->iobase1 = pci_resource_start(pci_dev, 2);
1416         dev->iobase = pci_resource_start(pci_dev, 3);
1417         irq = pci_dev->irq;
1418
1419         /* Allocate readback buffer for AO channels. */
1420         devpriv->ao_readback = kmalloc(sizeof(devpriv->ao_readback[0]) *
1421                                        thisboard->ao_chans, GFP_KERNEL);
1422         if (!devpriv->ao_readback)
1423                 return -ENOMEM;
1424
1425
1426         /* Allocate buffer to hold values for AO channel scan. */
1427         devpriv->ao_scan_vals = kmalloc(sizeof(devpriv->ao_scan_vals[0]) *
1428                                         thisboard->ao_chans, GFP_KERNEL);
1429         if (!devpriv->ao_scan_vals)
1430                 return -ENOMEM;
1431
1432
1433         /* Allocate buffer to hold AO channel scan order. */
1434         devpriv->ao_scan_order = kmalloc(sizeof(devpriv->ao_scan_order[0]) *
1435                                          thisboard->ao_chans, GFP_KERNEL);
1436         if (!devpriv->ao_scan_order)
1437                 return -ENOMEM;
1438
1439
1440         /* Disable interrupt sources. */
1441         devpriv->intsce = 0;
1442         outb(0, devpriv->iobase1 + PCI224_INT_SCE);
1443
1444         /* Initialize the DAC hardware. */
1445         outw(PCI224_DACCON_GLOBALRESET, dev->iobase + PCI224_DACCON);
1446         outw(0, dev->iobase + PCI224_DACCEN);
1447         outw(0, dev->iobase + PCI224_FIFOSIZ);
1448         devpriv->daccon = (PCI224_DACCON_TRIG_SW | PCI224_DACCON_POLAR_BI |
1449                            PCI224_DACCON_FIFOENAB |
1450                            PCI224_DACCON_FIFOINTR_EMPTY);
1451         outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
1452              dev->iobase + PCI224_DACCON);
1453
1454         /* Allocate subdevices.  There is only one!  */
1455         ret = alloc_subdevices(dev, 1);
1456         if (ret < 0) {
1457                 printk(KERN_ERR "comedi%d: error! out of memory!\n",
1458                        dev->minor);
1459                 return ret;
1460         }
1461
1462         s = dev->subdevices + 0;
1463         /* Analog output subdevice. */
1464         s->type = COMEDI_SUBD_AO;
1465         s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
1466         s->n_chan = thisboard->ao_chans;
1467         s->maxdata = (1 << thisboard->ao_bits) - 1;
1468         s->insn_write = &pci224_ao_insn_write;
1469         s->insn_read = &pci224_ao_insn_read;
1470         s->len_chanlist = s->n_chan;
1471
1472         dev->write_subdev = s;
1473         s->do_cmd = &pci224_ao_cmd;
1474         s->do_cmdtest = &pci224_ao_cmdtest;
1475         s->cancel = &pci224_ao_cancel;
1476         s->munge = &pci224_ao_munge;
1477
1478         /* Sort out channel range options. */
1479         if (thisboard->model == pci234_model) {
1480                 /* PCI234 range options. */
1481                 const struct comedi_lrange **range_table_list;
1482
1483                 s->range_table_list = range_table_list =
1484                     kmalloc(sizeof(struct comedi_lrange *) * s->n_chan,
1485                             GFP_KERNEL);
1486                 if (!s->range_table_list)
1487                         return -ENOMEM;
1488
1489                 for (n = 2; n < 3 + s->n_chan; n++) {
1490                         if (it->options[n] < 0 || it->options[n] > 1) {
1491                                 printk(KERN_WARNING "comedi%d: %s: warning! "
1492                                        "bad options[%u]=%d\n",
1493                                        dev->minor, DRIVER_NAME, n,
1494                                        it->options[n]);
1495                         }
1496                 }
1497                 for (n = 0; n < s->n_chan; n++) {
1498                         if (n < COMEDI_NDEVCONFOPTS - 3 &&
1499                             it->options[3 + n] == 1) {
1500                                 if (it->options[2] == 1)
1501                                         range_table_list[n] = &range_pci234_ext;
1502                                 else
1503                                         range_table_list[n] = &range_bipolar5;
1504
1505                         } else {
1506                                 if (it->options[2] == 1) {
1507                                         range_table_list[n] =
1508                                             &range_pci234_ext2;
1509                                 } else {
1510                                         range_table_list[n] = &range_bipolar10;
1511                                 }
1512                         }
1513                 }
1514                 devpriv->hwrange = hwrange_pci234;
1515         } else {
1516                 /* PCI224 range options. */
1517                 if (it->options[2] == 1) {
1518                         s->range_table = &range_pci224_external;
1519                         devpriv->hwrange = hwrange_pci224_external;
1520                 } else {
1521                         if (it->options[2] != 0) {
1522                                 printk(KERN_WARNING "comedi%d: %s: warning! "
1523                                        "bad options[2]=%d\n",
1524                                        dev->minor, DRIVER_NAME, it->options[2]);
1525                         }
1526                         s->range_table = &range_pci224_internal;
1527                         devpriv->hwrange = hwrange_pci224_internal;
1528                 }
1529         }
1530
1531         dev->board_name = thisboard->name;
1532
1533         if (irq) {
1534                 ret = request_irq(irq, pci224_interrupt, IRQF_SHARED,
1535                                   DRIVER_NAME, dev);
1536                 if (ret < 0) {
1537                         printk(KERN_ERR "comedi%d: error! "
1538                                "unable to allocate irq %u\n", dev->minor, irq);
1539                         return ret;
1540                 } else {
1541                         dev->irq = irq;
1542                 }
1543         }
1544
1545         printk(KERN_INFO "comedi%d: %s ", dev->minor, dev->board_name);
1546         printk("(pci %s) ", pci_name(pci_dev));
1547         if (irq)
1548                 printk("(irq %u%s) ", irq, (dev->irq ? "" : " UNAVAILABLE"));
1549         else
1550                 printk("(no irq) ");
1551
1552
1553         printk("attached\n");
1554
1555         return 1;
1556 }
1557
1558 /*
1559  * _detach is called to deconfigure a device.  It should deallocate
1560  * resources.
1561  * This function is also called when _attach() fails, so it should be
1562  * careful not to release resources that were not necessarily
1563  * allocated by _attach().  dev->private and dev->subdevices are
1564  * deallocated automatically by the core.
1565  */
1566 static int pci224_detach(struct comedi_device *dev)
1567 {
1568         printk(KERN_DEBUG "comedi%d: %s: detach\n", dev->minor, DRIVER_NAME);
1569
1570         if (dev->irq)
1571                 free_irq(dev->irq, dev);
1572
1573         if (dev->subdevices) {
1574                 struct comedi_subdevice *s;
1575
1576                 s = dev->subdevices + 0;
1577                 /* AO subdevice */
1578                 kfree(s->range_table_list);
1579         }
1580         if (devpriv) {
1581                 kfree(devpriv->ao_readback);
1582                 kfree(devpriv->ao_scan_vals);
1583                 kfree(devpriv->ao_scan_order);
1584                 if (devpriv->pci_dev) {
1585                         if (dev->iobase)
1586                                 comedi_pci_disable(devpriv->pci_dev);
1587
1588                         pci_dev_put(devpriv->pci_dev);
1589                 }
1590         }
1591         if (dev->board_name) {
1592                 printk(KERN_INFO "comedi%d: %s removed\n",
1593                        dev->minor, dev->board_name);
1594         }
1595
1596         return 0;
1597 }
1598
1599 MODULE_AUTHOR("Comedi http://www.comedi.org");
1600 MODULE_DESCRIPTION("Comedi low-level driver");
1601 MODULE_LICENSE("GPL");