drivers/staging/comedi/drivers/amplc_dio200.c

   1 /*
   2     comedi/drivers/amplc_dio200.c
   3     Driver for Amplicon PC272E and PCI272 DIO boards.
   4     (Support for other boards in Amplicon 200 series may be added at
   5     a later date, e.g. PCI215.)
   6
   7     Copyright (C) 2005 MEV Ltd. <http://www.mev.co.uk/>
   8
   9     COMEDI - Linux Control and Measurement Device Interface
  10     Copyright (C) 1998,2000 David A. Schleef <ds@schleef.org>
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21
  22     You should have received a copy of the GNU General Public License
  23     along with this program; if not, write to the Free Software
  24     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25
  26 */
  27 /*
  28  * Driver: amplc_dio200
  29  * Description: Amplicon 200 Series Digital I/O
  30  * Author: Ian Abbott <abbotti@mev.co.uk>
  31  * Devices: [Amplicon] PC212E (pc212e), PC214E (pc214e), PC215E (pc215e),
  32  *   PCI215 (pci215), PCIe215 (pcie215), PC218E (pc218e), PCIe236 (pcie236),
  33  *   PC272E (pc272e), PCI272 (pci272), PCIe296 (pcie296)
  34  * Updated: Wed, 24 Oct 2012 16:22:34 +0100
  35  * Status: works
  36  *
  37  * Configuration options - PC212E, PC214E, PC215E, PC218E, PC272E:
  38  *   [0] - I/O port base address
  39  *   [1] - IRQ (optional, but commands won't work without it)
  40  *
  41  * Manual configuration of PCI(e) cards is not supported; they are configured
  42  * automatically.
  43  *
  44  * Passing a zero for an option is the same as leaving it unspecified.
  45  *
  46  * SUBDEVICES
  47  *
  48  *                     PC212E         PC214E      PC215E/PCI215
  49  *                  -------------  -------------  -------------
  50  *   Subdevices           6              4              5
  51  *    0                 PPI-X          PPI-X          PPI-X
  52  *    1                 CTR-Y1         PPI-Y          PPI-Y
  53  *    2                 CTR-Y2         CTR-Z1*        CTR-Z1
  54  *    3                 CTR-Z1       INTERRUPT*       CTR-Z2
  55  *    4                 CTR-Z2                      INTERRUPT
  56  *    5               INTERRUPT
  57  *
  58  *                     PCIe215        PC218E         PCIe236
  59  *                  -------------  -------------  -------------
  60  *   Subdevices           8              7              8
  61  *    0                 PPI-X          CTR-X1         PPI-X
  62  *    1                 UNUSED         CTR-X2         UNUSED
  63  *    2                 PPI-Y          CTR-Y1         UNUSED
  64  *    3                 UNUSED         CTR-Y2         UNUSED
  65  *    4                 CTR-Z1         CTR-Z1         CTR-Z1
  66  *    5                 CTR-Z2         CTR-Z2         CTR-Z2
  67  *    6                 TIMER        INTERRUPT        TIMER
  68  *    7               INTERRUPT                     INTERRUPT
  69  *
  70  *                  PC272E/PCI272     PCIe296
  71  *                  -------------  -------------
  72  *   Subdevices           4              8
  73  *    0                 PPI-X          PPI-X1
  74  *    1                 PPI-Y          PPI-X2
  75  *    2                 PPI-Z          PPI-Y1
  76  *    3               INTERRUPT        PPI-Y2
  77  *    4                                CTR-Z1
  78  *    5                                CTR-Z2
  79  *    6                                TIMER
  80  *    7                              INTERRUPT
  81  *
  82  * Each PPI is a 8255 chip providing 24 DIO channels.  The DIO channels
  83  * are configurable as inputs or outputs in four groups:
  84  *
  85  *   Port A  - channels  0 to  7
  86  *   Port B  - channels  8 to 15
  87  *   Port CL - channels 16 to 19
  88  *   Port CH - channels 20 to 23
  89  *
  90  * Only mode 0 of the 8255 chips is supported.
  91  *
  92  * Each CTR is a 8254 chip providing 3 16-bit counter channels.  Each
  93  * channel is configured individually with INSN_CONFIG instructions.  The
  94  * specific type of configuration instruction is specified in data[0].
  95  * Some configuration instructions expect an additional parameter in
  96  * data[1]; others return a value in data[1].  The following configuration
  97  * instructions are supported:
  98  *
  99  *   INSN_CONFIG_SET_COUNTER_MODE.  Sets the counter channel's mode and
 100  *     BCD/binary setting specified in data[1].
 101  *
 102  *   INSN_CONFIG_8254_READ_STATUS.  Reads the status register value for the
 103  *     counter channel into data[1].
 104  *
 105  *   INSN_CONFIG_SET_CLOCK_SRC.  Sets the counter channel's clock source as
 106  *     specified in data[1] (this is a hardware-specific value).  Not
 107  *     supported on PC214E.  For the other boards, valid clock sources are
 108  *     0 to 7 as follows:
 109  *
 110  *       0.  CLK n, the counter channel's dedicated CLK input from the SK1
 111  *         connector.  (N.B. for other values, the counter channel's CLKn
 112  *         pin on the SK1 connector is an output!)
 113  *       1.  Internal 10 MHz clock.
 114  *       2.  Internal 1 MHz clock.
 115  *       3.  Internal 100 kHz clock.
 116  *       4.  Internal 10 kHz clock.
 117  *       5.  Internal 1 kHz clock.
 118  *       6.  OUT n-1, the output of counter channel n-1 (see note 1 below).
 119  *       7.  Ext Clock, the counter chip's dedicated Ext Clock input from
 120  *         the SK1 connector.  This pin is shared by all three counter
 121  *         channels on the chip.
 122  *
 123  *     For the PCIe boards, clock sources in the range 0 to 31 are allowed
 124  *     and the following additional clock sources are defined:
 125  *
 126  *       8.  HIGH logic level.
 127  *       9.  LOW logic level.
 128  *      10.  "Pattern present" signal.
 129  *      11.  Internal 20 MHz clock.
 130  *
 131  *   INSN_CONFIG_GET_CLOCK_SRC.  Returns the counter channel's current
 132  *     clock source in data[1].  For internal clock sources, data[2] is set
 133  *     to the period in ns.
 134  *
 135  *   INSN_CONFIG_SET_GATE_SRC.  Sets the counter channel's gate source as
 136  *     specified in data[2] (this is a hardware-specific value).  Not
 137  *     supported on PC214E.  For the other boards, valid gate sources are 0
 138  *     to 7 as follows:
 139  *
 140  *       0.  VCC (internal +5V d.c.), i.e. gate permanently enabled.
 141  *       1.  GND (internal 0V d.c.), i.e. gate permanently disabled.
 142  *       2.  GAT n, the counter channel's dedicated GAT input from the SK1
 143  *         connector.  (N.B. for other values, the counter channel's GATn
 144  *         pin on the SK1 connector is an output!)
 145  *       3.  /OUT n-2, the inverted output of counter channel n-2 (see note
 146  *         2 below).
 147  *       4.  Reserved.
 148  *       5.  Reserved.
 149  *       6.  Reserved.
 150  *       7.  Reserved.
 151  *
 152  *     For the PCIe boards, gate sources in the range 0 to 31 are allowed;
 153  *     the following additional clock sources and clock sources 6 and 7 are
 154  *     (re)defined:
 155  *
 156  *       6.  /GAT n, negated version of the counter channel's dedicated
 157  *         GAT input (negated version of gate source 2).
 158  *       7.  OUT n-2, the non-inverted output of counter channel n-2
 159  *         (negated version of gate source 3).
 160  *       8.  "Pattern present" signal, HIGH while pattern present.
 161  *       9.  "Pattern occurred" latched signal, latches HIGH when pattern
 162  *         occurs.
 163  *      10.  "Pattern gone away" latched signal, latches LOW when pattern
 164  *         goes away after it occurred.
 165  *      11.  Negated "pattern present" signal, LOW while pattern present
 166  *         (negated version of gate source 8).
 167  *      12.  Negated "pattern occurred" latched signal, latches LOW when
 168  *         pattern occurs (negated version of gate source 9).
 169  *      13.  Negated "pattern gone away" latched signal, latches LOW when
 170  *         pattern goes away after it occurred (negated version of gate
 171  *         source 10).
 172  *
 173  *   INSN_CONFIG_GET_GATE_SRC.  Returns the counter channel's current gate
 174  *     source in data[2].
 175  *
 176  * Clock and gate interconnection notes:
 177  *
 178  *   1.  Clock source OUT n-1 is the output of the preceding channel on the
 179  *   same counter subdevice if n > 0, or the output of channel 2 on the
 180  *   preceding counter subdevice (see note 3) if n = 0.
 181  *
 182  *   2.  Gate source /OUT n-2 is the inverted output of channel 0 on the
 183  *   same counter subdevice if n = 2, or the inverted output of channel n+1
 184  *   on the preceding counter subdevice (see note 3) if n < 2.
 185  *
 186  *   3.  The counter subdevices are connected in a ring, so the highest
 187  *   counter subdevice precedes the lowest.
 188  *
 189  * The 'TIMER' subdevice is a free-running 32-bit timer subdevice.
 190  *
 191  * The 'INTERRUPT' subdevice pretends to be a digital input subdevice.  The
 192  * digital inputs come from the interrupt status register.  The number of
 193  * channels matches the number of interrupt sources.  The PC214E does not
 194  * have an interrupt status register; see notes on 'INTERRUPT SOURCES'
 195  * below.
 196  *
 197  * INTERRUPT SOURCES
 198  *
 199  *                     PC212E         PC214E      PC215E/PCI215
 200  *                  -------------  -------------  -------------
 201  *   Sources              6              1              6
 202  *    0               PPI-X-C0       JUMPER-J5      PPI-X-C0
 203  *    1               PPI-X-C3                      PPI-X-C3
 204  *    2              CTR-Y1-OUT1                    PPI-Y-C0
 205  *    3              CTR-Y2-OUT1                    PPI-Y-C3
 206  *    4              CTR-Z1-OUT1                   CTR-Z1-OUT1
 207  *    5              CTR-Z2-OUT1                   CTR-Z2-OUT1
 208  *
 209  *                     PCIe215        PC218E         PCIe236
 210  *                  -------------  -------------  -------------
 211  *   Sources              6              6              6
 212  *    0               PPI-X-C0      CTR-X1-OUT1     PPI-X-C0
 213  *    1               PPI-X-C3      CTR-X2-OUT1     PPI-X-C3
 214  *    2               PPI-Y-C0      CTR-Y1-OUT1      unused
 215  *    3               PPI-Y-C3      CTR-Y2-OUT1      unused
 216  *    4              CTR-Z1-OUT1    CTR-Z1-OUT1    CTR-Z1-OUT1
 217  *    5              CTR-Z2-OUT1    CTR-Z2-OUT1    CTR-Z2-OUT1
 218  *
 219  *                  PC272E/PCI272     PCIe296
 220  *                  -------------  -------------
 221  *   Sources              6              6
 222  *    0               PPI-X-C0       PPI-X1-C0
 223  *    1               PPI-X-C3       PPI-X1-C3
 224  *    2               PPI-Y-C0       PPI-Y1-C0
 225  *    3               PPI-Y-C3       PPI-Y1-C3
 226  *    4               PPI-Z-C0      CTR-Z1-OUT1
 227  *    5               PPI-Z-C3      CTR-Z2-OUT1
 228  *
 229  * When an interrupt source is enabled in the interrupt source enable
 230  * register, a rising edge on the source signal latches the corresponding
 231  * bit to 1 in the interrupt status register.
 232  *
 233  * When the interrupt status register value as a whole (actually, just the
 234  * 6 least significant bits) goes from zero to non-zero, the board will
 235  * generate an interrupt.  For level-triggered hardware interrupts (PCI
 236  * card), the interrupt will remain asserted until the interrupt status
 237  * register is cleared to zero.  For edge-triggered hardware interrupts
 238  * (ISA card), no further interrupts will occur until the interrupt status
 239  * register is cleared to zero.  To clear a bit to zero in the interrupt
 240  * status register, the corresponding interrupt source must be disabled
 241  * in the interrupt source enable register (there is no separate interrupt
 242  * clear register).
 243  *
 244  * The PC214E does not have an interrupt source enable register or an
 245  * interrupt status register; its 'INTERRUPT' subdevice has a single
 246  * channel and its interrupt source is selected by the position of jumper
 247  * J5.
 248  *
 249  * COMMANDS
 250  *
 251  * The driver supports a read streaming acquisition command on the
 252  * 'INTERRUPT' subdevice.  The channel list selects the interrupt sources
 253  * to be enabled.  All channels will be sampled together (convert_src ==
 254  * TRIG_NOW).  The scan begins a short time after the hardware interrupt
 255  * occurs, subject to interrupt latencies (scan_begin_src == TRIG_EXT,
 256  * scan_begin_arg == 0).  The value read from the interrupt status register
 257  * is packed into a short value, one bit per requested channel, in the
 258  * order they appear in the channel list.
 259  */
 260
 261 #include <linux/pci.h>
 262 #include <linux/interrupt.h>
 263 #include <linux/slab.h>
 264
 265 #include "../comedidev.h"
 266
 267 #include "comedi_fc.h"
 268 #include "8253.h"
 269
 270 #define DIO200_DRIVER_NAME      "amplc_dio200"
 271
 272 #define DO_ISA  IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA)
 273 #define DO_PCI  IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI)
 274
 275 /* PCI IDs */
 276 #define PCI_DEVICE_ID_AMPLICON_PCI272 0x000a
 277 #define PCI_DEVICE_ID_AMPLICON_PCI215 0x000b
 278 #define PCI_DEVICE_ID_AMPLICON_PCIE236 0x0011
 279 #define PCI_DEVICE_ID_AMPLICON_PCIE215 0x0012
 280 #define PCI_DEVICE_ID_AMPLICON_PCIE296 0x0014
 281
 282 /* 8255 control register bits */
 283 #define CR_C_LO_IO      0x01
 284 #define CR_B_IO         0x02
 285 #define CR_B_MODE       0x04
 286 #define CR_C_HI_IO      0x08
 287 #define CR_A_IO         0x10
 288 #define CR_A_MODE(a)    ((a)<<5)
 289 #define CR_CW           0x80
 290
 291 /* 200 series registers */
 292 #define DIO200_IO_SIZE          0x20
 293 #define DIO200_PCIE_IO_SIZE     0x4000
 294 #define DIO200_XCLK_SCE         0x18    /* Group X clock selection register */
 295 #define DIO200_YCLK_SCE         0x19    /* Group Y clock selection register */
 296 #define DIO200_ZCLK_SCE         0x1a    /* Group Z clock selection register */
 297 #define DIO200_XGAT_SCE         0x1b    /* Group X gate selection register */
 298 #define DIO200_YGAT_SCE         0x1c    /* Group Y gate selection register */
 299 #define DIO200_ZGAT_SCE         0x1d    /* Group Z gate selection register */
 300 #define DIO200_INT_SCE          0x1e    /* Interrupt enable/status register */
 301 /* Extra registers for new PCIe boards */
 302 #define DIO200_ENHANCE          0x20    /* 1 to enable enhanced features */
 303 #define DIO200_VERSION          0x24    /* Hardware version register */
 304 #define DIO200_TS_CONFIG        0x600   /* Timestamp timer config register */
 305 #define DIO200_TS_COUNT         0x602   /* Timestamp timer count register */
 306
 307 /*
 308  * Functions for constructing value for DIO_200_?CLK_SCE and
 309  * DIO_200_?GAT_SCE registers:
 310  *
 311  * 'which' is: 0 for CTR-X1, CTR-Y1, CTR-Z1; 1 for CTR-X2, CTR-Y2 or CTR-Z2.
 312  * 'chan' is the channel: 0, 1 or 2.
 313  * 'source' is the signal source: 0 to 7, or 0 to 31 for "enhanced" boards.
 314  */
 315 static unsigned char clk_gat_sce(unsigned int which, unsigned int chan,
 316                                  unsigned int source)
 317 {
 318         return (which << 5) | (chan << 3) |
 319                ((source & 030) << 3) | (source & 007);
 320 }
 321
 322 static unsigned char clk_sce(unsigned int which, unsigned int chan,
 323                              unsigned int source)
 324 {
 325         return clk_gat_sce(which, chan, source);
 326 }
 327
 328 static unsigned char gat_sce(unsigned int which, unsigned int chan,
 329                              unsigned int source)
 330 {
 331         return clk_gat_sce(which, chan, source);
 332 }
 333
 334 /*
 335  * Periods of the internal clock sources in nanoseconds.
 336  */
 337 static const unsigned int clock_period[32] = {
 338         [1] = 100,              /* 10 MHz */
 339         [2] = 1000,             /* 1 MHz */
 340         [3] = 10000,            /* 100 kHz */
 341         [4] = 100000,           /* 10 kHz */
 342         [5] = 1000000,          /* 1 kHz */
 343         [11] = 50,              /* 20 MHz (enhanced boards) */
 344         /* clock sources 12 and later reserved for enhanced boards */
 345 };
 346
 347 /*
 348  * Timestamp timer configuration register (for new PCIe boards).
 349  */
 350 #define TS_CONFIG_RESET         0x100   /* Reset counter to zero. */
 351 #define TS_CONFIG_CLK_SRC_MASK  0x0FF   /* Clock source. */
 352 #define TS_CONFIG_MAX_CLK_SRC   2       /* Maximum clock source value. */
 353
 354 /*
 355  * Periods of the timestamp timer clock sources in nanoseconds.
 356  */
 357 static const unsigned int ts_clock_period[TS_CONFIG_MAX_CLK_SRC + 1] = {
 358         1,                      /* 1 nanosecond (but with 20 ns granularity). */
 359         1000,                   /* 1 microsecond. */
 360         1000000,                /* 1 millisecond. */
 361 };
 362
 363 /*
 364  * Register region.
 365  */
 366 enum dio200_regtype { no_regtype = 0, io_regtype, mmio_regtype };
 367 struct dio200_region {
 368         union {
 369                 unsigned long iobase;           /* I/O base address */
 370                 unsigned char __iomem *membase; /* mapped MMIO base address */
 371         } u;
 372         enum dio200_regtype regtype;
 373 };
 374
 375 /*
 376  * Board descriptions.
 377  */
 378
 379 enum dio200_bustype { isa_bustype, pci_bustype };
 380
 381 enum dio200_model {
 382         pc212e_model,
 383         pc214e_model,
 384         pc215e_model, pci215_model, pcie215_model,
 385         pc218e_model,
 386         pcie236_model,
 387         pc272e_model, pci272_model,
 388         pcie296_model,
 389 };
 390
 391 enum dio200_layout_idx {
 392 #if DO_ISA
 393         pc212_layout,
 394         pc214_layout,
 395 #endif
 396         pc215_layout,
 397 #if DO_ISA
 398         pc218_layout,
 399 #endif
 400         pc272_layout,
 401 #if DO_PCI
 402         pcie215_layout,
 403         pcie236_layout,
 404         pcie296_layout,
 405 #endif
 406 };
 407
 408 struct dio200_board {
 409         const char *name;
 410         unsigned short devid;
 411         enum dio200_bustype bustype;
 412         enum dio200_model model;
 413         enum dio200_layout_idx layout;
 414         unsigned char mainbar;
 415         unsigned char mainshift;
 416         unsigned int mainsize;
 417 };
 418
 419 static const struct dio200_board dio200_boards[] = {
 420 #if DO_ISA
 421         {
 422          .name = "pc212e",
 423          .bustype = isa_bustype,
 424          .model = pc212e_model,
 425          .layout = pc212_layout,
 426          .mainsize = DIO200_IO_SIZE,
 427          },
 428         {
 429          .name = "pc214e",
 430          .bustype = isa_bustype,
 431          .model = pc214e_model,
 432          .layout = pc214_layout,
 433          .mainsize = DIO200_IO_SIZE,
 434          },
 435         {
 436          .name = "pc215e",
 437          .bustype = isa_bustype,
 438          .model = pc215e_model,
 439          .layout = pc215_layout,
 440          .mainsize = DIO200_IO_SIZE,
 441          },
 442         {
 443          .name = "pc218e",
 444          .bustype = isa_bustype,
 445          .model = pc218e_model,
 446          .layout = pc218_layout,
 447          .mainsize = DIO200_IO_SIZE,
 448          },
 449         {
 450          .name = "pc272e",
 451          .bustype = isa_bustype,
 452          .model = pc272e_model,
 453          .layout = pc272_layout,
 454          .mainsize = DIO200_IO_SIZE,
 455          },
 456 #endif
 457 #if DO_PCI
 458         {
 459          .name = "pci215",
 460          .devid = PCI_DEVICE_ID_AMPLICON_PCI215,
 461          .bustype = pci_bustype,
 462          .model = pci215_model,
 463          .layout = pc215_layout,
 464          .mainbar = 2,
 465          .mainsize = DIO200_IO_SIZE,
 466          },
 467         {
 468          .name = "pci272",
 469          .devid = PCI_DEVICE_ID_AMPLICON_PCI272,
 470          .bustype = pci_bustype,
 471          .model = pci272_model,
 472          .layout = pc272_layout,
 473          .mainbar = 2,
 474          .mainsize = DIO200_IO_SIZE,
 475          },
 476         {
 477          .name = "pcie215",
 478          .devid = PCI_DEVICE_ID_AMPLICON_PCIE215,
 479          .bustype = pci_bustype,
 480          .model = pcie215_model,
 481          .layout = pcie215_layout,
 482          .mainbar = 1,
 483          .mainshift = 3,
 484          .mainsize = DIO200_PCIE_IO_SIZE,
 485          },
 486         {
 487          .name = "pcie236",
 488          .devid = PCI_DEVICE_ID_AMPLICON_PCIE236,
 489          .bustype = pci_bustype,
 490          .model = pcie236_model,
 491          .layout = pcie236_layout,
 492          .mainbar = 1,
 493          .mainshift = 3,
 494          .mainsize = DIO200_PCIE_IO_SIZE,
 495          },
 496         {
 497          .name = "pcie296",
 498          .devid = PCI_DEVICE_ID_AMPLICON_PCIE296,
 499          .bustype = pci_bustype,
 500          .model = pcie296_model,
 501          .layout = pcie296_layout,
 502          .mainbar = 1,
 503          .mainshift = 3,
 504          .mainsize = DIO200_PCIE_IO_SIZE,
 505          },
 506 #endif
 507 };
 508
 509 /*
 510  * Layout descriptions - some ISA and PCI board descriptions share the same
 511  * layout.
 512  */
 513
 514 enum dio200_sdtype { sd_none, sd_intr, sd_8255, sd_8254, sd_timer };
 515
 516 #define DIO200_MAX_SUBDEVS      8
 517 #define DIO200_MAX_ISNS         6
 518
 519 struct dio200_layout {
 520         unsigned short n_subdevs;       /* number of subdevices */
 521         unsigned char sdtype[DIO200_MAX_SUBDEVS];       /* enum dio200_sdtype */
 522         unsigned char sdinfo[DIO200_MAX_SUBDEVS];       /* depends on sdtype */
 523         char has_int_sce;       /* has interrupt enable/status register */
 524         char has_clk_gat_sce;   /* has clock/gate selection registers */
 525         char has_enhancements;  /* has enhanced features */
 526 };
 527
 528 static const struct dio200_layout dio200_layouts[] = {
 529 #if DO_ISA
 530         [pc212_layout] = {
 531                           .n_subdevs = 6,
 532                           .sdtype = {sd_8255, sd_8254, sd_8254, sd_8254,
 533                                      sd_8254,
 534                                      sd_intr},
 535                           .sdinfo = {0x00, 0x08, 0x0C, 0x10, 0x14,
 536                                      0x3F},
 537                           .has_int_sce = 1,
 538                           .has_clk_gat_sce = 1,
 539                           },
 540         [pc214_layout] = {
 541                           .n_subdevs = 4,
 542                           .sdtype = {sd_8255, sd_8255, sd_8254,
 543                                      sd_intr},
 544                           .sdinfo = {0x00, 0x08, 0x10, 0x01},
 545                           .has_int_sce = 0,
 546                           .has_clk_gat_sce = 0,
 547                           },
 548 #endif
 549         [pc215_layout] = {
 550                           .n_subdevs = 5,
 551                           .sdtype = {sd_8255, sd_8255, sd_8254,
 552                                      sd_8254,
 553                                      sd_intr},
 554                           .sdinfo = {0x00, 0x08, 0x10, 0x14, 0x3F},
 555                           .has_int_sce = 1,
 556                           .has_clk_gat_sce = 1,
 557                           },
 558 #if DO_ISA
 559         [pc218_layout] = {
 560                           .n_subdevs = 7,
 561                           .sdtype = {sd_8254, sd_8254, sd_8255, sd_8254,
 562                                      sd_8254,
 563                                      sd_intr},
 564                           .sdinfo = {0x00, 0x04, 0x08, 0x0C, 0x10,
 565                                      0x14,
 566                                      0x3F},
 567                           .has_int_sce = 1,
 568                           .has_clk_gat_sce = 1,
 569                           },
 570 #endif
 571         [pc272_layout] = {
 572                           .n_subdevs = 4,
 573                           .sdtype = {sd_8255, sd_8255, sd_8255,
 574                                      sd_intr},
 575                           .sdinfo = {0x00, 0x08, 0x10, 0x3F},
 576                           .has_int_sce = 1,
 577                           .has_clk_gat_sce = 0,
 578                           },
 579 #if DO_PCI
 580         [pcie215_layout] = {
 581                           .n_subdevs = 8,
 582                           .sdtype = {sd_8255, sd_none, sd_8255, sd_none,
 583                                      sd_8254, sd_8254, sd_timer, sd_intr},
 584                           .sdinfo = {0x00, 0x00, 0x08, 0x00,
 585                                      0x10, 0x14, 0x00, 0x3F},
 586                           .has_int_sce = 1,
 587                           .has_clk_gat_sce = 1,
 588                           .has_enhancements = 1,
 589                           },
 590         [pcie236_layout] = {
 591                           .n_subdevs = 8,
 592                           .sdtype = {sd_8255, sd_none, sd_none, sd_none,
 593                                      sd_8254, sd_8254, sd_timer, sd_intr},
 594                           .sdinfo = {0x00, 0x00, 0x00, 0x00,
 595                                      0x10, 0x14, 0x00, 0x3F},
 596                           .has_int_sce = 1,
 597                           .has_clk_gat_sce = 1,
 598                           .has_enhancements = 1,
 599                           },
 600         [pcie296_layout] = {
 601                           .n_subdevs = 8,
 602                           .sdtype = {sd_8255, sd_8255, sd_8255, sd_8255,
 603                                      sd_8254, sd_8254, sd_timer, sd_intr},
 604                           .sdinfo = {0x00, 0x04, 0x08, 0x0C,
 605                                      0x10, 0x14, 0x00, 0x3F},
 606                           .has_int_sce = 1,
 607                           .has_clk_gat_sce = 1,
 608                           .has_enhancements = 1,
 609                           },
 610 #endif
 611 };
 612
 613 /* this structure is for data unique to this hardware driver.  If
 614    several hardware drivers keep similar information in this structure,
 615    feel free to suggest moving the variable to the struct comedi_device struct.
 616  */
 617 struct dio200_private {
 618         struct dio200_region io;        /* Register region */
 619         int intr_sd;
 620 };
 621
 622 struct dio200_subdev_8254 {
 623         unsigned int ofs;               /* Counter base offset */
 624         unsigned int clk_sce_ofs;       /* CLK_SCE base address */
 625         unsigned int gat_sce_ofs;       /* GAT_SCE base address */
 626         int which;                      /* Bit 5 of CLK_SCE or GAT_SCE */
 627         unsigned int clock_src[3];      /* Current clock sources */
 628         unsigned int gate_src[3];       /* Current gate sources */
 629         spinlock_t spinlock;
 630 };
 631
 632 struct dio200_subdev_8255 {
 633         unsigned int ofs;               /* DIO base offset */
 634 };
 635
 636 struct dio200_subdev_intr {
 637         unsigned int ofs;
 638         spinlock_t spinlock;
 639         int active;
 640         unsigned int valid_isns;
 641         unsigned int enabled_isns;
 642         unsigned int stopcount;
 643         int continuous;
 644 };
 645
 646 static inline const struct dio200_layout *
 647 dio200_board_layout(const struct dio200_board *board)
 648 {
 649         return &dio200_layouts[board->layout];
 650 }
 651
 652 static inline const struct dio200_layout *
 653 dio200_dev_layout(struct comedi_device *dev)
 654 {
 655         return dio200_board_layout(comedi_board(dev));
 656 }
 657
 658 static inline bool is_pci_board(const struct dio200_board *board)
 659 {
 660         return DO_PCI && board->bustype == pci_bustype;
 661 }
 662
 663 static inline bool is_isa_board(const struct dio200_board *board)
 664 {
 665         return DO_ISA && board->bustype == isa_bustype;
 666 }
 667
 668 /*
 669  * Read 8-bit register.
 670  */
 671 static unsigned char dio200_read8(struct comedi_device *dev,
 672                                   unsigned int offset)
 673 {
 674         const struct dio200_board *thisboard = comedi_board(dev);
 675         struct dio200_private *devpriv = dev->private;
 676
 677         offset <<= thisboard->mainshift;
 678         if (devpriv->io.regtype == io_regtype)
 679                 return inb(devpriv->io.u.iobase + offset);
 680         else
 681                 return readb(devpriv->io.u.membase + offset);
 682 }
 683
 684 /*
 685  * Write 8-bit register.
 686  */
 687 static void dio200_write8(struct comedi_device *dev, unsigned int offset,
 688                           unsigned char val)
 689 {
 690         const struct dio200_board *thisboard = comedi_board(dev);
 691         struct dio200_private *devpriv = dev->private;
 692
 693         offset <<= thisboard->mainshift;
 694         if (devpriv->io.regtype == io_regtype)
 695                 outb(val, devpriv->io.u.iobase + offset);
 696         else
 697                 writeb(val, devpriv->io.u.membase + offset);
 698 }
 699
 700 /*
 701  * Read 32-bit register.
 702  */
 703 static unsigned int dio200_read32(struct comedi_device *dev,
 704                                   unsigned int offset)
 705 {
 706         const struct dio200_board *thisboard = comedi_board(dev);
 707         struct dio200_private *devpriv = dev->private;
 708
 709         offset <<= thisboard->mainshift;
 710         if (devpriv->io.regtype == io_regtype)
 711                 return inl(devpriv->io.u.iobase + offset);
 712         else
 713                 return readl(devpriv->io.u.membase + offset);
 714 }
 715
 716 /*
 717  * Write 32-bit register.
 718  */
 719 static void dio200_write32(struct comedi_device *dev, unsigned int offset,
 720                            unsigned int val)
 721 {
 722         const struct dio200_board *thisboard = comedi_board(dev);
 723         struct dio200_private *devpriv = dev->private;
 724
 725         offset <<= thisboard->mainshift;
 726         if (devpriv->io.regtype == io_regtype)
 727                 outl(val, devpriv->io.u.iobase + offset);
 728         else
 729                 writel(val, devpriv->io.u.membase + offset);
 730 }
 731
 732 /*
 733  * This function looks for a board matching the supplied PCI device.
 734  */
 735 static const struct dio200_board *
 736 dio200_find_pci_board(struct pci_dev *pci_dev)
 737 {
 738         unsigned int i;
 739
 740         for (i = 0; i < ARRAY_SIZE(dio200_boards); i++)
 741                 if (is_pci_board(&dio200_boards[i]) &&
 742                     pci_dev->device == dio200_boards[i].devid)
 743                         return &dio200_boards[i];
 744         return NULL;
 745 }
 746
 747 /*
 748  * This function checks and requests an I/O region, reporting an error
 749  * if there is a conflict.
 750  */
 751 static int
 752 dio200_request_region(struct comedi_device *dev,
 753                       unsigned long from, unsigned long extent)
 754 {
 755         if (!from || !request_region(from, extent, DIO200_DRIVER_NAME)) {
 756                 dev_err(dev->class_dev, "I/O port conflict (%#lx,%lu)!\n",
 757                         from, extent);
 758                 return -EIO;
 759         }
 760         return 0;
 761 }
 762
 763 /*
 764  * 'insn_bits' function for an 'INTERRUPT' subdevice.
 765  */
 766 static int
 767 dio200_subdev_intr_insn_bits(struct comedi_device *dev,
 768                              struct comedi_subdevice *s,
 769                              struct comedi_insn *insn, unsigned int *data)
 770 {
 771         const struct dio200_layout *layout = dio200_dev_layout(dev);
 772         struct dio200_subdev_intr *subpriv = s->private;
 773
 774         if (layout->has_int_sce) {
 775                 /* Just read the interrupt status register.  */
 776                 data[1] = dio200_read8(dev, subpriv->ofs) & subpriv->valid_isns;
 777         } else {
 778                 /* No interrupt status register. */
 779                 data[0] = 0;
 780         }
 781
 782         return insn->n;
 783 }
 784
 785 /*
 786  * Called to stop acquisition for an 'INTERRUPT' subdevice.
 787  */
 788 static void dio200_stop_intr(struct comedi_device *dev,
 789                              struct comedi_subdevice *s)
 790 {
 791         const struct dio200_layout *layout = dio200_dev_layout(dev);
 792         struct dio200_subdev_intr *subpriv = s->private;
 793
 794         subpriv->active = 0;
 795         subpriv->enabled_isns = 0;
 796         if (layout->has_int_sce)
 797                 dio200_write8(dev, subpriv->ofs, 0);
 798 }
 799
 800 /*
 801  * Called to start acquisition for an 'INTERRUPT' subdevice.
 802  */
 803 static int dio200_start_intr(struct comedi_device *dev,
 804                              struct comedi_subdevice *s)
 805 {
 806         unsigned int n;
 807         unsigned isn_bits;
 808         const struct dio200_layout *layout = dio200_dev_layout(dev);
 809         struct dio200_subdev_intr *subpriv = s->private;
 810         struct comedi_cmd *cmd = &s->async->cmd;
 811         int retval = 0;
 812
 813         if (!subpriv->continuous && subpriv->stopcount == 0) {
 814                 /* An empty acquisition! */
 815                 s->async->events |= COMEDI_CB_EOA;
 816                 subpriv->active = 0;
 817                 retval = 1;
 818         } else {
 819                 /* Determine interrupt sources to enable. */
 820                 isn_bits = 0;
 821                 if (cmd->chanlist) {
 822                         for (n = 0; n < cmd->chanlist_len; n++)
 823                                 isn_bits |= (1U << CR_CHAN(cmd->chanlist[n]));
 824                 }
 825                 isn_bits &= subpriv->valid_isns;
 826                 /* Enable interrupt sources. */
 827                 subpriv->enabled_isns = isn_bits;
 828                 if (layout->has_int_sce)
 829                         dio200_write8(dev, subpriv->ofs, isn_bits);
 830         }
 831
 832         return retval;
 833 }
 834
 835 /*
 836  * Internal trigger function to start acquisition for an 'INTERRUPT' subdevice.
 837  */
 838 static int
 839 dio200_inttrig_start_intr(struct comedi_device *dev, struct comedi_subdevice *s,
 840                           unsigned int trignum)
 841 {
 842         struct dio200_subdev_intr *subpriv;
 843         unsigned long flags;
 844         int event = 0;
 845
 846         if (trignum != 0)
 847                 return -EINVAL;
 848
 849         subpriv = s->private;
 850
 851         spin_lock_irqsave(&subpriv->spinlock, flags);
 852         s->async->inttrig = NULL;
 853         if (subpriv->active)
 854                 event = dio200_start_intr(dev, s);
 855
 856         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 857
 858         if (event)
 859                 comedi_event(dev, s);
 860
 861         return 1;
 862 }
 863
 864 /*
 865  * This is called from the interrupt service routine to handle a read
 866  * scan on an 'INTERRUPT' subdevice.
 867  */
 868 static int dio200_handle_read_intr(struct comedi_device *dev,
 869                                    struct comedi_subdevice *s)
 870 {
 871         const struct dio200_layout *layout = dio200_dev_layout(dev);
 872         struct dio200_subdev_intr *subpriv = s->private;
 873         unsigned triggered;
 874         unsigned intstat;
 875         unsigned cur_enabled;
 876         unsigned int oldevents;
 877         unsigned long flags;
 878
 879         triggered = 0;
 880
 881         spin_lock_irqsave(&subpriv->spinlock, flags);
 882         oldevents = s->async->events;
 883         if (layout->has_int_sce) {
 884                 /*
 885                  * Collect interrupt sources that have triggered and disable
 886                  * them temporarily.  Loop around until no extra interrupt
 887                  * sources have triggered, at which point, the valid part of
 888                  * the interrupt status register will read zero, clearing the
 889                  * cause of the interrupt.
 890                  *
 891                  * Mask off interrupt sources already seen to avoid infinite
 892                  * loop in case of misconfiguration.
 893                  */
 894                 cur_enabled = subpriv->enabled_isns;
 895                 while ((intstat = (dio200_read8(dev, subpriv->ofs) &
 896                                    subpriv->valid_isns & ~triggered)) != 0) {
 897                         triggered |= intstat;
 898                         cur_enabled &= ~triggered;
 899                         dio200_write8(dev, subpriv->ofs, cur_enabled);
 900                 }
 901         } else {
 902                 /*
 903                  * No interrupt status register.  Assume the single interrupt
 904                  * source has triggered.
 905                  */
 906                 triggered = subpriv->enabled_isns;
 907         }
 908
 909         if (triggered) {
 910                 /*
 911                  * Some interrupt sources have triggered and have been
 912                  * temporarily disabled to clear the cause of the interrupt.
 913                  *
 914                  * Reenable them NOW to minimize the time they are disabled.
 915                  */
 916                 cur_enabled = subpriv->enabled_isns;
 917                 if (layout->has_int_sce)
 918                         dio200_write8(dev, subpriv->ofs, cur_enabled);
 919
 920                 if (subpriv->active) {
 921                         /*
 922                          * The command is still active.
 923                          *
 924                          * Ignore interrupt sources that the command isn't
 925                          * interested in (just in case there's a race
 926                          * condition).
 927                          */
 928                         if (triggered & subpriv->enabled_isns) {
 929                                 /* Collect scan data. */
 930                                 short val;
 931                                 unsigned int n, ch, len;
 932
 933                                 val = 0;
 934                                 len = s->async->cmd.chanlist_len;
 935                                 for (n = 0; n < len; n++) {
 936                                         ch = CR_CHAN(s->async->cmd.chanlist[n]);
 937                                         if (triggered & (1U << ch))
 938                                                 val |= (1U << n);
 939                                 }
 940                                 /* Write the scan to the buffer. */
 941                                 if (comedi_buf_put(s->async, val)) {
 942                                         s->async->events |= (COMEDI_CB_BLOCK |
 943                                                              COMEDI_CB_EOS);
 944                                 } else {
 945                                         /* Error!  Stop acquisition.  */
 946                                         dio200_stop_intr(dev, s);
 947                                         s->async->events |= COMEDI_CB_ERROR
 948                                             | COMEDI_CB_OVERFLOW;
 949                                         comedi_error(dev, "buffer overflow");
 950                                 }
 951
 952                                 /* Check for end of acquisition. */
 953                                 if (!subpriv->continuous) {
 954                                         /* stop_src == TRIG_COUNT */
 955                                         if (subpriv->stopcount > 0) {
 956                                                 subpriv->stopcount--;
 957                                                 if (subpriv->stopcount == 0) {
 958                                                         s->async->events |=
 959                                                             COMEDI_CB_EOA;
 960                                                         dio200_stop_intr(dev,
 961                                                                          s);
 962                                                 }
 963                                         }
 964                                 }
 965                         }
 966                 }
 967         }
 968         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 969
 970         if (oldevents != s->async->events)
 971                 comedi_event(dev, s);
 972
 973         return (triggered != 0);
 974 }
 975
 976 /*
 977  * 'cancel' function for an 'INTERRUPT' subdevice.
 978  */
 979 static int dio200_subdev_intr_cancel(struct comedi_device *dev,
 980                                      struct comedi_subdevice *s)
 981 {
 982         struct dio200_subdev_intr *subpriv = s->private;
 983         unsigned long flags;
 984
 985         spin_lock_irqsave(&subpriv->spinlock, flags);
 986         if (subpriv->active)
 987                 dio200_stop_intr(dev, s);
 988
 989         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 990
 991         return 0;
 992 }
 993
 994 /*
 995  * 'do_cmdtest' function for an 'INTERRUPT' subdevice.
 996  */
 997 static int
 998 dio200_subdev_intr_cmdtest(struct comedi_device *dev,
 999                            struct comedi_subdevice *s, struct comedi_cmd *cmd)
1000 {
1001         int err = 0;
1002
1003         /* Step 1 : check if triggers are trivially valid */
1004
1005         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
1006         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
1007         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
1008         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1009         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1010
1011         if (err)
1012                 return 1;
1013
1014         /* Step 2a : make sure trigger sources are unique */
1015
1016         err |= cfc_check_trigger_is_unique(cmd->start_src);
1017         err |= cfc_check_trigger_is_unique(cmd->stop_src);
1018
1019         /* Step 2b : and mutually compatible */
1020
1021         if (err)
1022                 return 2;
1023
1024         /* Step 3: check if arguments are trivially valid */
1025
1026         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
1027         err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
1028         err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
1029         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
1030
1031         switch (cmd->stop_src) {
1032         case TRIG_COUNT:
1033                 /* any count allowed */
1034                 break;
1035         case TRIG_NONE:
1036                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
1037                 break;
1038         default:
1039                 break;
1040         }
1041
1042         if (err)
1043                 return 3;
1044
1045         /* step 4: fix up any arguments */
1046
1047         /* if (err) return 4; */
1048
1049         return 0;
1050 }
1051
1052 /*
1053  * 'do_cmd' function for an 'INTERRUPT' subdevice.
1054  */
1055 static int dio200_subdev_intr_cmd(struct comedi_device *dev,
1056                                   struct comedi_subdevice *s)
1057 {
1058         struct comedi_cmd *cmd = &s->async->cmd;
1059         struct dio200_subdev_intr *subpriv = s->private;
1060         unsigned long flags;
1061         int event = 0;
1062
1063         spin_lock_irqsave(&subpriv->spinlock, flags);
1064         subpriv->active = 1;
1065
1066         /* Set up end of acquisition. */
1067         switch (cmd->stop_src) {
1068         case TRIG_COUNT:
1069                 subpriv->continuous = 0;
1070                 subpriv->stopcount = cmd->stop_arg;
1071                 break;
1072         default:
1073                 /* TRIG_NONE */
1074                 subpriv->continuous = 1;
1075                 subpriv->stopcount = 0;
1076                 break;
1077         }
1078
1079         /* Set up start of acquisition. */
1080         switch (cmd->start_src) {
1081         case TRIG_INT:
1082                 s->async->inttrig = dio200_inttrig_start_intr;
1083                 break;
1084         default:
1085                 /* TRIG_NOW */
1086                 event = dio200_start_intr(dev, s);
1087                 break;
1088         }
1089         spin_unlock_irqrestore(&subpriv->spinlock, flags);
1090
1091         if (event)
1092                 comedi_event(dev, s);
1093
1094         return 0;
1095 }
1096
1097 /*
1098  * This function initializes an 'INTERRUPT' subdevice.
1099  */
1100 static int
1101 dio200_subdev_intr_init(struct comedi_device *dev, struct comedi_subdevice *s,
1102                         unsigned int offset, unsigned valid_isns)
1103 {
1104         const struct dio200_layout *layout = dio200_dev_layout(dev);
1105         struct dio200_subdev_intr *subpriv;
1106
1107         subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
1108         if (!subpriv)
1109                 return -ENOMEM;
1110
1111         subpriv->ofs = offset;
1112         subpriv->valid_isns = valid_isns;
1113         spin_lock_init(&subpriv->spinlock);
1114
1115         if (layout->has_int_sce)
1116                 /* Disable interrupt sources. */
1117                 dio200_write8(dev, subpriv->ofs, 0);
1118
1119         s->private = subpriv;
1120         s->type = COMEDI_SUBD_DI;
1121         s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
1122         if (layout->has_int_sce) {
1123                 s->n_chan = DIO200_MAX_ISNS;
1124                 s->len_chanlist = DIO200_MAX_ISNS;
1125         } else {
1126                 /* No interrupt source register.  Support single channel. */
1127                 s->n_chan = 1;
1128                 s->len_chanlist = 1;
1129         }
1130         s->range_table = &range_digital;
1131         s->maxdata = 1;
1132         s->insn_bits = dio200_subdev_intr_insn_bits;
1133         s->do_cmdtest = dio200_subdev_intr_cmdtest;
1134         s->do_cmd = dio200_subdev_intr_cmd;
1135         s->cancel = dio200_subdev_intr_cancel;
1136
1137         return 0;
1138 }
1139
1140 /*
1141  * This function cleans up an 'INTERRUPT' subdevice.
1142  */
1143 static void
1144 dio200_subdev_intr_cleanup(struct comedi_device *dev,
1145                            struct comedi_subdevice *s)
1146 {
1147         struct dio200_subdev_intr *subpriv = s->private;
1148         kfree(subpriv);
1149 }
1150
1151 /*
1152  * Interrupt service routine.
1153  */
1154 static irqreturn_t dio200_interrupt(int irq, void *d)
1155 {
1156         struct comedi_device *dev = d;
1157         struct dio200_private *devpriv = dev->private;
1158         struct comedi_subdevice *s;
1159         int handled;
1160
1161         if (!dev->attached)
1162                 return IRQ_NONE;
1163
1164         if (devpriv->intr_sd >= 0) {
1165                 s = &dev->subdevices[devpriv->intr_sd];
1166                 handled = dio200_handle_read_intr(dev, s);
1167         } else {
1168                 handled = 0;
1169         }
1170
1171         return IRQ_RETVAL(handled);
1172 }
1173
1174 /*
1175  * Read an '8254' counter subdevice channel.
1176  */
1177 static unsigned int
1178 dio200_subdev_8254_read_chan(struct comedi_device *dev,
1179                              struct comedi_subdevice *s, unsigned int chan)
1180 {
1181         struct dio200_subdev_8254 *subpriv = s->private;
1182         unsigned int val;
1183
1184         /* latch counter */
1185         val = chan << 6;
1186         dio200_write8(dev, subpriv->ofs + i8254_control_reg, val);
1187         /* read lsb, msb */
1188         val = dio200_read8(dev, subpriv->ofs + chan);
1189         val += dio200_read8(dev, subpriv->ofs + chan) << 8;
1190         return val;
1191 }
1192
1193 /*
1194  * Write an '8254' subdevice channel.
1195  */
1196 static void
1197 dio200_subdev_8254_write_chan(struct comedi_device *dev,
1198                               struct comedi_subdevice *s, unsigned int chan,
1199                               unsigned int count)
1200 {
1201         struct dio200_subdev_8254 *subpriv = s->private;
1202
1203         /* write lsb, msb */
1204         dio200_write8(dev, subpriv->ofs + chan, count & 0xff);
1205         dio200_write8(dev, subpriv->ofs + chan, (count >> 8) & 0xff);
1206 }
1207
1208 /*
1209  * Set mode of an '8254' subdevice channel.
1210  */
1211 static void
1212 dio200_subdev_8254_set_mode(struct comedi_device *dev,
1213                             struct comedi_subdevice *s, unsigned int chan,
1214                             unsigned int mode)
1215 {
1216         struct dio200_subdev_8254 *subpriv = s->private;
1217         unsigned int byte;
1218
1219         byte = chan << 6;
1220         byte |= 0x30;           /* access order: lsb, msb */
1221         byte |= (mode & 0xf);   /* counter mode and BCD|binary */
1222         dio200_write8(dev, subpriv->ofs + i8254_control_reg, byte);
1223 }
1224
1225 /*
1226  * Read status byte of an '8254' counter subdevice channel.
1227  */
1228 static unsigned int
1229 dio200_subdev_8254_status(struct comedi_device *dev,
1230                           struct comedi_subdevice *s, unsigned int chan)
1231 {
1232         struct dio200_subdev_8254 *subpriv = s->private;
1233
1234         /* latch status */
1235         dio200_write8(dev, subpriv->ofs + i8254_control_reg,
1236                       0xe0 | (2 << chan));
1237         /* read status */
1238         return dio200_read8(dev, subpriv->ofs + chan);
1239 }
1240
1241 /*
1242  * Handle 'insn_read' for an '8254' counter subdevice.
1243  */
1244 static int
1245 dio200_subdev_8254_read(struct comedi_device *dev, struct comedi_subdevice *s,
1246                         struct comedi_insn *insn, unsigned int *data)
1247 {
1248         struct dio200_subdev_8254 *subpriv = s->private;
1249         int chan = CR_CHAN(insn->chanspec);
1250         unsigned int n;
1251         unsigned long flags;
1252
1253         for (n = 0; n < insn->n; n++) {
1254                 spin_lock_irqsave(&subpriv->spinlock, flags);
1255                 data[n] = dio200_subdev_8254_read_chan(dev, s, chan);
1256                 spin_unlock_irqrestore(&subpriv->spinlock, flags);
1257         }
1258         return insn->n;
1259 }
1260
1261 /*
1262  * Handle 'insn_write' for an '8254' counter subdevice.
1263  */
1264 static int
1265 dio200_subdev_8254_write(struct comedi_device *dev, struct comedi_subdevice *s,
1266                          struct comedi_insn *insn, unsigned int *data)
1267 {
1268         struct dio200_subdev_8254 *subpriv = s->private;
1269         int chan = CR_CHAN(insn->chanspec);
1270         unsigned int n;
1271         unsigned long flags;
1272
1273         for (n = 0; n < insn->n; n++) {
1274                 spin_lock_irqsave(&subpriv->spinlock, flags);
1275                 dio200_subdev_8254_write_chan(dev, s, chan, data[n]);
1276                 spin_unlock_irqrestore(&subpriv->spinlock, flags);
1277         }
1278         return insn->n;
1279 }
1280
1281 /*
1282  * Set gate source for an '8254' counter subdevice channel.
1283  */
1284 static int
1285 dio200_subdev_8254_set_gate_src(struct comedi_device *dev,
1286                                 struct comedi_subdevice *s,
1287                                 unsigned int counter_number,
1288                                 unsigned int gate_src)
1289 {
1290         const struct dio200_layout *layout = dio200_dev_layout(dev);
1291         struct dio200_subdev_8254 *subpriv = s->private;
1292         unsigned char byte;
1293
1294         if (!layout->has_clk_gat_sce)
1295                 return -1;
1296         if (counter_number > 2)
1297                 return -1;
1298         if (gate_src > (layout->has_enhancements ? 31 : 7))
1299                 return -1;
1300
1301         subpriv->gate_src[counter_number] = gate_src;
1302         byte = gat_sce(subpriv->which, counter_number, gate_src);
1303         dio200_write8(dev, subpriv->gat_sce_ofs, byte);
1304
1305         return 0;
1306 }
1307
1308 /*
1309  * Get gate source for an '8254' counter subdevice channel.
1310  */
1311 static int
1312 dio200_subdev_8254_get_gate_src(struct comedi_device *dev,
1313                                 struct comedi_subdevice *s,
1314                                 unsigned int counter_number)
1315 {
1316         const struct dio200_layout *layout = dio200_dev_layout(dev);
1317         struct dio200_subdev_8254 *subpriv = s->private;
1318
1319         if (!layout->has_clk_gat_sce)
1320                 return -1;
1321         if (counter_number > 2)
1322                 return -1;
1323
1324         return subpriv->gate_src[counter_number];
1325 }
1326
1327 /*
1328  * Set clock source for an '8254' counter subdevice channel.
1329  */
1330 static int
1331 dio200_subdev_8254_set_clock_src(struct comedi_device *dev,
1332                                  struct comedi_subdevice *s,
1333                                  unsigned int counter_number,
1334                                  unsigned int clock_src)
1335 {
1336         const struct dio200_layout *layout = dio200_dev_layout(dev);
1337         struct dio200_subdev_8254 *subpriv = s->private;
1338         unsigned char byte;
1339
1340         if (!layout->has_clk_gat_sce)
1341                 return -1;
1342         if (counter_number > 2)
1343                 return -1;
1344         if (clock_src > (layout->has_enhancements ? 31 : 7))
1345                 return -1;
1346
1347         subpriv->clock_src[counter_number] = clock_src;
1348         byte = clk_sce(subpriv->which, counter_number, clock_src);
1349         dio200_write8(dev, subpriv->clk_sce_ofs, byte);
1350
1351         return 0;
1352 }
1353
1354 /*
1355  * Get clock source for an '8254' counter subdevice channel.
1356  */
1357 static int
1358 dio200_subdev_8254_get_clock_src(struct comedi_device *dev,
1359                                  struct comedi_subdevice *s,
1360                                  unsigned int counter_number,
1361                                  unsigned int *period_ns)
1362 {
1363         const struct dio200_layout *layout = dio200_dev_layout(dev);
1364         struct dio200_subdev_8254 *subpriv = s->private;
1365         unsigned clock_src;
1366
1367         if (!layout->has_clk_gat_sce)
1368                 return -1;
1369         if (counter_number > 2)
1370                 return -1;
1371
1372         clock_src = subpriv->clock_src[counter_number];
1373         *period_ns = clock_period[clock_src];
1374         return clock_src;
1375 }
1376
1377 /*
1378  * Handle 'insn_config' for an '8254' counter subdevice.
1379  */
1380 static int
1381 dio200_subdev_8254_config(struct comedi_device *dev, struct comedi_subdevice *s,
1382                           struct comedi_insn *insn, unsigned int *data)
1383 {
1384         struct dio200_subdev_8254 *subpriv = s->private;
1385         int ret = 0;
1386         int chan = CR_CHAN(insn->chanspec);
1387         unsigned long flags;
1388
1389         spin_lock_irqsave(&subpriv->spinlock, flags);
1390         switch (data[0]) {
1391         case INSN_CONFIG_SET_COUNTER_MODE:
1392                 if (data[1] > (I8254_MODE5 | I8254_BINARY))
1393                         ret = -EINVAL;
1394                 else
1395                         dio200_subdev_8254_set_mode(dev, s, chan, data[1]);
1396                 break;
1397         case INSN_CONFIG_8254_READ_STATUS:
1398                 data[1] = dio200_subdev_8254_status(dev, s, chan);
1399                 break;
1400         case INSN_CONFIG_SET_GATE_SRC:
1401                 ret = dio200_subdev_8254_set_gate_src(dev, s, chan, data[2]);
1402                 if (ret < 0)
1403                         ret = -EINVAL;
1404                 break;
1405         case INSN_CONFIG_GET_GATE_SRC:
1406                 ret = dio200_subdev_8254_get_gate_src(dev, s, chan);
1407                 if (ret < 0) {
1408                         ret = -EINVAL;
1409                         break;
1410                 }
1411                 data[2] = ret;
1412                 break;
1413         case INSN_CONFIG_SET_CLOCK_SRC:
1414                 ret = dio200_subdev_8254_set_clock_src(dev, s, chan, data[1]);
1415                 if (ret < 0)
1416                         ret = -EINVAL;
1417                 break;
1418         case INSN_CONFIG_GET_CLOCK_SRC:
1419                 ret = dio200_subdev_8254_get_clock_src(dev, s, chan, &data[2]);
1420                 if (ret < 0) {
1421                         ret = -EINVAL;
1422                         break;
1423                 }
1424                 data[1] = ret;
1425                 break;
1426         default:
1427                 ret = -EINVAL;
1428                 break;
1429         }
1430         spin_unlock_irqrestore(&subpriv->spinlock, flags);
1431         return ret < 0 ? ret : insn->n;
1432 }
1433
1434 /*
1435  * This function initializes an '8254' counter subdevice.
1436  */
1437 static int
1438 dio200_subdev_8254_init(struct comedi_device *dev, struct comedi_subdevice *s,
1439                         unsigned int offset)
1440 {
1441         const struct dio200_layout *layout = dio200_dev_layout(dev);
1442         struct dio200_subdev_8254 *subpriv;
1443         unsigned int chan;
1444
1445         subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
1446         if (!subpriv)
1447                 return -ENOMEM;
1448
1449         s->private = subpriv;
1450         s->type = COMEDI_SUBD_COUNTER;
1451         s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
1452         s->n_chan = 3;
1453         s->maxdata = 0xFFFF;
1454         s->insn_read = dio200_subdev_8254_read;
1455         s->insn_write = dio200_subdev_8254_write;
1456         s->insn_config = dio200_subdev_8254_config;
1457
1458         spin_lock_init(&subpriv->spinlock);
1459         subpriv->ofs = offset;
1460         if (layout->has_clk_gat_sce) {
1461                 /* Derive CLK_SCE and GAT_SCE register offsets from
1462                  * 8254 offset. */
1463                 subpriv->clk_sce_ofs = DIO200_XCLK_SCE + (offset >> 3);
1464                 subpriv->gat_sce_ofs = DIO200_XGAT_SCE + (offset >> 3);
1465                 subpriv->which = (offset >> 2) & 1;
1466         }
1467
1468         /* Initialize channels. */
1469         for (chan = 0; chan < 3; chan++) {
1470                 dio200_subdev_8254_set_mode(dev, s, chan,
1471                                             I8254_MODE0 | I8254_BINARY);
1472                 if (layout->has_clk_gat_sce) {
1473                         /* Gate source 0 is VCC (logic 1). */
1474                         dio200_subdev_8254_set_gate_src(dev, s, chan, 0);
1475                         /* Clock source 0 is the dedicated clock input. */
1476                         dio200_subdev_8254_set_clock_src(dev, s, chan, 0);
1477                 }
1478         }
1479
1480         return 0;
1481 }
1482
1483 /*
1484  * This function cleans up an '8254' counter subdevice.
1485  */
1486 static void
1487 dio200_subdev_8254_cleanup(struct comedi_device *dev,
1488                            struct comedi_subdevice *s)
1489 {
1490         struct dio200_subdev_intr *subpriv = s->private;
1491         kfree(subpriv);
1492 }
1493
1494 /*
1495  * This function sets I/O directions for an '8255' DIO subdevice.
1496  */
1497 static void dio200_subdev_8255_set_dir(struct comedi_device *dev,
1498                                        struct comedi_subdevice *s)
1499 {
1500         struct dio200_subdev_8255 *subpriv = s->private;
1501         int config;
1502
1503         config = CR_CW;
1504         /* 1 in io_bits indicates output, 1 in config indicates input */
1505         if (!(s->io_bits & 0x0000ff))
1506                 config |= CR_A_IO;
1507         if (!(s->io_bits & 0x00ff00))
1508                 config |= CR_B_IO;
1509         if (!(s->io_bits & 0x0f0000))
1510                 config |= CR_C_LO_IO;
1511         if (!(s->io_bits & 0xf00000))
1512                 config |= CR_C_HI_IO;
1513         dio200_write8(dev, subpriv->ofs + 3, config);
1514 }
1515
1516 /*
1517  * Handle 'insn_bits' for an '8255' DIO subdevice.
1518  */
1519 static int dio200_subdev_8255_bits(struct comedi_device *dev,
1520                                    struct comedi_subdevice *s,
1521                                    struct comedi_insn *insn, unsigned int *data)
1522 {
1523         struct dio200_subdev_8255 *subpriv = s->private;
1524
1525         if (data[0]) {
1526                 s->state &= ~data[0];
1527                 s->state |= (data[0] & data[1]);
1528                 if (data[0] & 0xff)
1529                         dio200_write8(dev, subpriv->ofs, s->state & 0xff);
1530                 if (data[0] & 0xff00)
1531                         dio200_write8(dev, subpriv->ofs + 1,
1532                                       (s->state >> 8) & 0xff);
1533                 if (data[0] & 0xff0000)
1534                         dio200_write8(dev, subpriv->ofs + 2,
1535                                       (s->state >> 16) & 0xff);
1536         }
1537         data[1] = dio200_read8(dev, subpriv->ofs);
1538         data[1] |= dio200_read8(dev, subpriv->ofs + 1) << 8;
1539         data[1] |= dio200_read8(dev, subpriv->ofs + 2) << 16;
1540         return 2;
1541 }
1542
1543 /*
1544  * Handle 'insn_config' for an '8255' DIO subdevice.
1545  */
1546 static int dio200_subdev_8255_config(struct comedi_device *dev,
1547                                      struct comedi_subdevice *s,
1548                                      struct comedi_insn *insn,
1549                                      unsigned int *data)
1550 {
1551         unsigned int mask;
1552         unsigned int bits;
1553
1554         mask = 1 << CR_CHAN(insn->chanspec);
1555         if (mask & 0x0000ff)
1556                 bits = 0x0000ff;
1557         else if (mask & 0x00ff00)
1558                 bits = 0x00ff00;
1559         else if (mask & 0x0f0000)
1560                 bits = 0x0f0000;
1561         else
1562                 bits = 0xf00000;
1563         switch (data[0]) {
1564         case INSN_CONFIG_DIO_INPUT:
1565                 s->io_bits &= ~bits;
1566                 break;
1567         case INSN_CONFIG_DIO_OUTPUT:
1568                 s->io_bits |= bits;
1569                 break;
1570         case INSN_CONFIG_DIO_QUERY:
1571                 data[1] = (s->io_bits & bits) ? COMEDI_OUTPUT : COMEDI_INPUT;
1572                 return insn->n;
1573                 break;
1574         default:
1575                 return -EINVAL;
1576         }
1577         dio200_subdev_8255_set_dir(dev, s);
1578         return 1;
1579 }
1580
1581 /*
1582  * This function initializes an '8255' DIO subdevice.
1583  *
1584  * offset is the offset to the 8255 chip.
1585  */
1586 static int dio200_subdev_8255_init(struct comedi_device *dev,
1587                                    struct comedi_subdevice *s,
1588                                    unsigned int offset)
1589 {
1590         struct dio200_subdev_8255 *subpriv;
1591
1592         subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
1593         if (!subpriv)
1594                 return -ENOMEM;
1595         subpriv->ofs = offset;
1596         s->private = subpriv;
1597         s->type = COMEDI_SUBD_DIO;
1598         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
1599         s->n_chan = 24;
1600         s->range_table = &range_digital;
1601         s->maxdata = 1;
1602         s->insn_bits = dio200_subdev_8255_bits;
1603         s->insn_config = dio200_subdev_8255_config;
1604         s->state = 0;
1605         s->io_bits = 0;
1606         dio200_subdev_8255_set_dir(dev, s);
1607         return 0;
1608 }
1609
1610 /*
1611  * This function cleans up an '8255' DIO subdevice.
1612  */
1613 static void dio200_subdev_8255_cleanup(struct comedi_device *dev,
1614                                        struct comedi_subdevice *s)
1615 {
1616         struct dio200_subdev_8255 *subpriv = s->private;
1617
1618         kfree(subpriv);
1619 }
1620
1621 /*
1622  * Handle 'insn_read' for a timer subdevice.
1623  */
1624 static int dio200_subdev_timer_read(struct comedi_device *dev,
1625                                     struct comedi_subdevice *s,
1626                                     struct comedi_insn *insn,
1627                                     unsigned int *data)
1628 {
1629         unsigned int n;
1630
1631         for (n = 0; n < insn->n; n++)
1632                 data[n] = dio200_read32(dev, DIO200_TS_COUNT);
1633         return n;
1634 }
1635
1636 /*
1637  * Reset timer subdevice.
1638  */
1639 static void dio200_subdev_timer_reset(struct comedi_device *dev,
1640                                       struct comedi_subdevice *s)
1641 {
1642         unsigned int clock;
1643
1644         clock = dio200_read32(dev, DIO200_TS_CONFIG) & TS_CONFIG_CLK_SRC_MASK;
1645         dio200_write32(dev, DIO200_TS_CONFIG, clock | TS_CONFIG_RESET);
1646         dio200_write32(dev, DIO200_TS_CONFIG, clock);
1647 }
1648
1649 /*
1650  * Get timer subdevice clock source and period.
1651  */
1652 static void dio200_subdev_timer_get_clock_src(struct comedi_device *dev,
1653                                               struct comedi_subdevice *s,
1654                                               unsigned int *src,
1655                                               unsigned int *period)
1656 {
1657         unsigned int clk;
1658
1659         clk = dio200_read32(dev, DIO200_TS_CONFIG) & TS_CONFIG_CLK_SRC_MASK;
1660         *src = clk;
1661         *period = (clk < ARRAY_SIZE(ts_clock_period)) ?
1662                   ts_clock_period[clk] : 0;
1663 }
1664
1665 /*
1666  * Set timer subdevice clock source.
1667  */
1668 static int dio200_subdev_timer_set_clock_src(struct comedi_device *dev,
1669                                              struct comedi_subdevice *s,
1670                                              unsigned int src)
1671 {
1672         if (src > TS_CONFIG_MAX_CLK_SRC)
1673                 return -EINVAL;
1674         dio200_write32(dev, DIO200_TS_CONFIG, src);
1675         return 0;
1676 }
1677
1678 /*
1679  * Handle 'insn_config' for a timer subdevice.
1680  */
1681 static int dio200_subdev_timer_config(struct comedi_device *dev,
1682                                       struct comedi_subdevice *s,
1683                                       struct comedi_insn *insn,
1684                                       unsigned int *data)
1685 {
1686         int ret = 0;
1687
1688         switch (data[0]) {
1689         case INSN_CONFIG_RESET:
1690                 dio200_subdev_timer_reset(dev, s);
1691                 break;
1692         case INSN_CONFIG_SET_CLOCK_SRC:
1693                 ret = dio200_subdev_timer_set_clock_src(dev, s, data[1]);
1694                 if (ret < 0)
1695                         ret = -EINVAL;
1696                 break;
1697         case INSN_CONFIG_GET_CLOCK_SRC:
1698                 dio200_subdev_timer_get_clock_src(dev, s, &data[1], &data[2]);
1699                 break;
1700         default:
1701                 ret = -EINVAL;
1702                 break;
1703         }
1704         return ret < 0 ? ret : insn->n;
1705 }
1706
1707 /*
1708  * This function initializes a timer subdevice.
1709  *
1710  * Uses the timestamp timer registers.  There is only one timestamp timer.
1711  */
1712 static int dio200_subdev_timer_init(struct comedi_device *dev,
1713                                     struct comedi_subdevice *s)
1714 {
1715         s->type = COMEDI_SUBD_TIMER;
1716         s->subdev_flags = SDF_READABLE | SDF_LSAMPL;
1717         s->n_chan = 1;
1718         s->maxdata = 0xFFFFFFFF;
1719         s->insn_read = dio200_subdev_timer_read;
1720         s->insn_config = dio200_subdev_timer_config;
1721         return 0;
1722 }
1723
1724 /*
1725  * This function cleans up a timer subdevice.
1726  */
1727 static void dio200_subdev_timer_cleanup(struct comedi_device *dev,
1728                                         struct comedi_subdevice *s)
1729 {
1730         /* Nothing to do. */
1731 }
1732
1733 /*
1734  * This function does some special set-up for the PCIe boards
1735  * PCIe215, PCIe236, PCIe296.
1736  */
1737 static int dio200_pcie_board_setup(struct comedi_device *dev)
1738 {
1739         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1740         void __iomem *brbase;
1741         resource_size_t brlen;
1742
1743         /*
1744          * The board uses Altera Cyclone IV with PCI-Express hard IP.
1745          * The FPGA configuration has the PCI-Express Avalon-MM Bridge
1746          * Control registers in PCI BAR 0, offset 0, and the length of
1747          * these registers is 0x4000.
1748          *
1749          * We need to write 0x80 to the "Avalon-MM to PCI-Express Interrupt
1750          * Enable" register at offset 0x50 to allow generation of PCIe
1751          * interrupts when RXmlrq_i is asserted in the SOPC Builder system.
1752          */
1753         brlen = pci_resource_len(pcidev, 0);
1754         if (brlen < 0x4000 ||
1755                         !(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
1756                 dev_err(dev->class_dev, "error! bad PCI region!\n");
1757                 return -EINVAL;
1758         }
1759         brbase = ioremap_nocache(pci_resource_start(pcidev, 0), brlen);
1760         if (!brbase) {
1761                 dev_err(dev->class_dev, "error! failed to map registers!\n");
1762                 return -ENOMEM;
1763         }
1764         writel(0x80, brbase + 0x50);
1765         iounmap(brbase);
1766         /* Enable "enhanced" features of board. */
1767         dio200_write8(dev, DIO200_ENHANCE, 1);
1768         return 0;
1769 }
1770
1771 static void dio200_report_attach(struct comedi_device *dev, unsigned int irq)
1772 {
1773         const struct dio200_board *thisboard = comedi_board(dev);
1774         struct dio200_private *devpriv = dev->private;
1775         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1776         char tmpbuf[60];
1777         int tmplen;
1778
1779         if (is_isa_board(thisboard))
1780                 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
1781                                    "(base %#lx) ", devpriv->io.u.iobase);
1782         else if (is_pci_board(thisboard))
1783                 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
1784                                    "(pci %s) ", pci_name(pcidev));
1785         else
1786                 tmplen = 0;
1787         if (irq)
1788                 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
1789                                     "(irq %u%s) ", irq,
1790                                     (dev->irq ? "" : " UNAVAILABLE"));
1791         else
1792                 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
1793                                     "(no irq) ");
1794         dev_info(dev->class_dev, "%s %sattached\n", dev->board_name, tmpbuf);
1795 }
1796
1797 static int dio200_common_attach(struct comedi_device *dev, unsigned int irq,
1798                                 unsigned long req_irq_flags)
1799 {
1800         const struct dio200_board *thisboard = comedi_board(dev);
1801         struct dio200_private *devpriv = dev->private;
1802         const struct dio200_layout *layout = dio200_board_layout(thisboard);
1803         struct comedi_subdevice *s;
1804         int sdx;
1805         unsigned int n;
1806         int ret;
1807
1808         devpriv->intr_sd = -1;
1809         dev->board_name = thisboard->name;
1810
1811         ret = comedi_alloc_subdevices(dev, layout->n_subdevs);
1812         if (ret)
1813                 return ret;
1814
1815         for (n = 0; n < dev->n_subdevices; n++) {
1816                 s = &dev->subdevices[n];
1817                 switch (layout->sdtype[n]) {
1818                 case sd_8254:
1819                         /* counter subdevice (8254) */
1820                         ret = dio200_subdev_8254_init(dev, s,
1821                                                       layout->sdinfo[n]);
1822                         if (ret < 0)
1823                                 return ret;
1824                         break;
1825                 case sd_8255:
1826                         /* digital i/o subdevice (8255) */
1827                         ret = dio200_subdev_8255_init(dev, s,
1828                                                       layout->sdinfo[n]);
1829                         if (ret < 0)
1830                                 return ret;
1831                         break;
1832                 case sd_intr:
1833                         /* 'INTERRUPT' subdevice */
1834                         if (irq) {
1835                                 ret = dio200_subdev_intr_init(dev, s,
1836                                                               DIO200_INT_SCE,
1837                                                               layout->sdinfo[n]
1838                                                              );
1839                                 if (ret < 0)
1840                                         return ret;
1841                                 devpriv->intr_sd = n;
1842                         } else {
1843                                 s->type = COMEDI_SUBD_UNUSED;
1844                         }
1845                         break;
1846                 case sd_timer:
1847                         /* Only on PCIe boards. */
1848                         if (DO_PCI) {
1849                                 ret = dio200_subdev_timer_init(dev, s);
1850                                 if (ret < 0)
1851                                         return ret;
1852                         } else {
1853                                 s->type = COMEDI_SUBD_UNUSED;
1854                         }
1855                         break;
1856                 default:
1857                         s->type = COMEDI_SUBD_UNUSED;
1858                         break;
1859                 }
1860         }
1861         sdx = devpriv->intr_sd;
1862         if (sdx >= 0 && sdx < dev->n_subdevices)
1863                 dev->read_subdev = &dev->subdevices[sdx];
1864         if (irq) {
1865                 if (request_irq(irq, dio200_interrupt, req_irq_flags,
1866                                 DIO200_DRIVER_NAME, dev) >= 0) {
1867                         dev->irq = irq;
1868                 } else {
1869                         dev_warn(dev->class_dev,
1870                                  "warning! irq %u unavailable!\n", irq);
1871                 }
1872         }
1873         dio200_report_attach(dev, irq);
1874         return 1;
1875 }
1876
1877 /*
1878  * Attach is called by the Comedi core to configure the driver
1879  * for a particular board.  If you specified a board_name array
1880  * in the driver structure, dev->board_ptr contains that
1881  * address.
1882  */
1883 static int dio200_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1884 {
1885         const struct dio200_board *thisboard = comedi_board(dev);
1886         struct dio200_private *devpriv;
1887         int ret;
1888
1889         dev_info(dev->class_dev, DIO200_DRIVER_NAME ": attach\n");
1890
1891         devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
1892         if (!devpriv)
1893                 return -ENOMEM;
1894         dev->private = devpriv;
1895
1896         /* Process options and reserve resources according to bus type. */
1897         if (is_isa_board(thisboard)) {
1898                 unsigned long iobase;
1899                 unsigned int irq;
1900
1901                 iobase = it->options[0];
1902                 irq = it->options[1];
1903                 ret = dio200_request_region(dev, iobase, thisboard->mainsize);
1904                 if (ret < 0)
1905                         return ret;
1906                 devpriv->io.u.iobase = iobase;
1907                 devpriv->io.regtype = io_regtype;
1908                 return dio200_common_attach(dev, irq, 0);
1909         } else if (is_pci_board(thisboard)) {
1910                 dev_err(dev->class_dev,
1911                         "Manual configuration of PCI board '%s' is not supported\n",
1912                         thisboard->name);
1913                 return -EIO;
1914         } else {
1915                 dev_err(dev->class_dev, DIO200_DRIVER_NAME
1916                         ": BUG! cannot determine board type!\n");
1917                 return -EINVAL;
1918         }
1919 }
1920
1921 /*
1922  * The auto_attach hook is called at PCI probe time via
1923  * comedi_pci_auto_config().  dev->board_ptr is NULL on entry.
1924  * There should be a board entry matching the supplied PCI device.
1925  */
1926 static int dio200_auto_attach(struct comedi_device *dev,
1927                                         unsigned long context_unused)
1928 {
1929         struct pci_dev *pci_dev = comedi_to_pci_dev(dev);
1930         const struct dio200_board *thisboard;
1931         struct dio200_private *devpriv;
1932         resource_size_t base, len;
1933         unsigned int bar;
1934         int ret;
1935
1936         if (!DO_PCI)
1937                 return -EINVAL;
1938
1939         dev_info(dev->class_dev, DIO200_DRIVER_NAME ": attach pci %s\n",
1940                  pci_name(pci_dev));
1941
1942         devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
1943         if (!devpriv)
1944                 return -ENOMEM;
1945         dev->private = devpriv;
1946
1947         dev->board_ptr = dio200_find_pci_board(pci_dev);
1948         if (dev->board_ptr == NULL) {
1949                 dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
1950                 return -EINVAL;
1951         }
1952         thisboard = comedi_board(dev);
1953         ret = comedi_pci_enable(pci_dev, DIO200_DRIVER_NAME);
1954         if (ret < 0) {
1955                 dev_err(dev->class_dev,
1956                         "error! cannot enable PCI device and request regions!\n");
1957                 return ret;
1958         }
1959         bar = thisboard->mainbar;
1960         base = pci_resource_start(pci_dev, bar);
1961         len = pci_resource_len(pci_dev, bar);
1962         if (len < thisboard->mainsize) {
1963                 dev_err(dev->class_dev, "error! PCI region size too small!\n");
1964                 return -EINVAL;
1965         }
1966         if ((pci_resource_flags(pci_dev, bar) & IORESOURCE_MEM) != 0) {
1967                 devpriv->io.u.membase = ioremap_nocache(base, len);
1968                 if (!devpriv->io.u.membase) {
1969                         dev_err(dev->class_dev,
1970                                 "error! cannot remap registers\n");
1971                         return -ENOMEM;
1972                 }
1973                 devpriv->io.regtype = mmio_regtype;
1974         } else {
1975                 devpriv->io.u.iobase = (unsigned long)base;
1976                 devpriv->io.regtype = io_regtype;
1977         }
1978         switch (thisboard->model) {
1979         case pcie215_model:
1980         case pcie236_model:
1981         case pcie296_model:
1982                 ret = dio200_pcie_board_setup(dev);
1983                 if (ret < 0)
1984                         return ret;
1985                 break;
1986         default:
1987                 break;
1988         }
1989         return dio200_common_attach(dev, pci_dev->irq, IRQF_SHARED);
1990 }
1991
1992 static void dio200_detach(struct comedi_device *dev)
1993 {
1994         const struct dio200_board *thisboard = comedi_board(dev);
1995         struct dio200_private *devpriv = dev->private;
1996         const struct dio200_layout *layout;
1997         unsigned n;
1998
1999         if (!thisboard || !devpriv)
2000                 return;
2001         if (dev->irq)
2002                 free_irq(dev->irq, dev);
2003         if (dev->subdevices) {
2004                 layout = dio200_board_layout(thisboard);
2005                 for (n = 0; n < dev->n_subdevices; n++) {
2006                         struct comedi_subdevice *s = &dev->subdevices[n];
2007                         switch (layout->sdtype[n]) {
2008                         case sd_8254:
2009                                 dio200_subdev_8254_cleanup(dev, s);
2010                                 break;
2011                         case sd_8255:
2012                                 dio200_subdev_8255_cleanup(dev, s);
2013                                 break;
2014                         case sd_intr:
2015                                 dio200_subdev_intr_cleanup(dev, s);
2016                                 break;
2017                         case sd_timer:
2018                                 /* Only on PCIe boards. */
2019                                 if (DO_PCI)
2020                                         dio200_subdev_timer_cleanup(dev, s);
2021                                 break;
2022                         default:
2023                                 break;
2024                         }
2025                 }
2026         }
2027         if (is_isa_board(thisboard)) {
2028                 if (devpriv->io.regtype == io_regtype)
2029                         release_region(devpriv->io.u.iobase,
2030                                        thisboard->mainsize);
2031         } else if (is_pci_board(thisboard)) {
2032                 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
2033                 if (pcidev) {
2034                         if (devpriv->io.regtype != no_regtype) {
2035                                 if (devpriv->io.regtype == mmio_regtype)
2036                                         iounmap(devpriv->io.u.membase);
2037                                 comedi_pci_disable(pcidev);
2038                         }
2039                 }
2040         }
2041 }
2042
2043 /*
2044  * The struct comedi_driver structure tells the Comedi core module
2045  * which functions to call to configure/deconfigure (attach/detach)
2046  * the board, and also about the kernel module that contains
2047  * the device code.
2048  */
2049 static struct comedi_driver amplc_dio200_driver = {
2050         .driver_name = DIO200_DRIVER_NAME,
2051         .module = THIS_MODULE,
2052         .attach = dio200_attach,
2053         .auto_attach = dio200_auto_attach,
2054         .detach = dio200_detach,
2055         .board_name = &dio200_boards[0].name,
2056         .offset = sizeof(struct dio200_board),
2057         .num_names = ARRAY_SIZE(dio200_boards),
2058 };
2059
2060 #if DO_PCI
2061 static DEFINE_PCI_DEVICE_TABLE(dio200_pci_table) = {
2062         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI215) },
2063         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI272) },
2064         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCIE236) },
2065         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCIE215) },
2066         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCIE296) },
2067         {0}
2068 };
2069
2070 MODULE_DEVICE_TABLE(pci, dio200_pci_table);
2071
2072 static int amplc_dio200_pci_probe(struct pci_dev *dev,
2073                                                    const struct pci_device_id
2074                                                    *ent)
2075 {
2076         return comedi_pci_auto_config(dev, &amplc_dio200_driver);
2077 }
2078
2079 static struct pci_driver amplc_dio200_pci_driver = {
2080         .name = DIO200_DRIVER_NAME,
2081         .id_table = dio200_pci_table,
2082         .probe = &amplc_dio200_pci_probe,
2083         .remove         = comedi_pci_auto_unconfig,
2084 };
2085 module_comedi_pci_driver(amplc_dio200_driver, amplc_dio200_pci_driver);
2086 #else
2087 module_comedi_driver(amplc_dio200_driver);
2088 #endif
2089
2090 MODULE_AUTHOR("Comedi http://www.comedi.org");
2091 MODULE_DESCRIPTION("Comedi low-level driver");
2092 MODULE_LICENSE("GPL");