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 or amplc_dio200), PC218E (pc218e), PC272E (pc272e),
  33   PCI272 (pci272 or amplc_dio200)
  34 Updated: Wed, 22 Oct 2008 13:36:02 +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 Configuration options - PCI215, PCI272:
  42   [0] - PCI bus of device (optional)
  43   [1] - PCI slot of device (optional)
  44   If bus/slot is not specified, the first available PCI device will
  45   be used.
  46
  47 Passing a zero for an option is the same as leaving it unspecified.
  48
  49 SUBDEVICES
  50
  51                     PC218E         PC212E      PC215E/PCI215
  52                  -------------  -------------  -------------
  53   Subdevices           7              6              5
  54    0                 CTR-X1         PPI-X          PPI-X
  55    1                 CTR-X2         CTR-Y1         PPI-Y
  56    2                 CTR-Y1         CTR-Y2         CTR-Z1
  57    3                 CTR-Y2         CTR-Z1         CTR-Z2
  58    4                 CTR-Z1         CTR-Z2       INTERRUPT
  59    5                 CTR-Z2       INTERRUPT
  60    6               INTERRUPT
  61
  62                     PC214E      PC272E/PCI272
  63                  -------------  -------------
  64   Subdevices           4              4
  65    0                 PPI-X          PPI-X
  66    1                 PPI-Y          PPI-Y
  67    2                 CTR-Z1*        PPI-Z
  68    3               INTERRUPT*     INTERRUPT
  69
  70 Each PPI is a 8255 chip providing 24 DIO channels.  The DIO channels
  71 are configurable as inputs or outputs in four groups:
  72
  73   Port A  - channels  0 to  7
  74   Port B  - channels  8 to 15
  75   Port CL - channels 16 to 19
  76   Port CH - channels 20 to 23
  77
  78 Only mode 0 of the 8255 chips is supported.
  79
  80 Each CTR is a 8254 chip providing 3 16-bit counter channels.  Each
  81 channel is configured individually with INSN_CONFIG instructions.  The
  82 specific type of configuration instruction is specified in data[0].
  83 Some configuration instructions expect an additional parameter in
  84 data[1]; others return a value in data[1].  The following configuration
  85 instructions are supported:
  86
  87   INSN_CONFIG_SET_COUNTER_MODE.  Sets the counter channel's mode and
  88     BCD/binary setting specified in data[1].
  89
  90   INSN_CONFIG_8254_READ_STATUS.  Reads the status register value for the
  91     counter channel into data[1].
  92
  93   INSN_CONFIG_SET_CLOCK_SRC.  Sets the counter channel's clock source as
  94     specified in data[1] (this is a hardware-specific value).  Not
  95     supported on PC214E.  For the other boards, valid clock sources are
  96     0 to 7 as follows:
  97
  98       0.  CLK n, the counter channel's dedicated CLK input from the SK1
  99         connector.  (N.B. for other values, the counter channel's CLKn
 100         pin on the SK1 connector is an output!)
 101       1.  Internal 10 MHz clock.
 102       2.  Internal 1 MHz clock.
 103       3.  Internal 100 kHz clock.
 104       4.  Internal 10 kHz clock.
 105       5.  Internal 1 kHz clock.
 106       6.  OUT n-1, the output of counter channel n-1 (see note 1 below).
 107       7.  Ext Clock, the counter chip's dedicated Ext Clock input from
 108         the SK1 connector.  This pin is shared by all three counter
 109         channels on the chip.
 110
 111   INSN_CONFIG_GET_CLOCK_SRC.  Returns the counter channel's current
 112     clock source in data[1].  For internal clock sources, data[2] is set
 113     to the period in ns.
 114
 115   INSN_CONFIG_SET_GATE_SRC.  Sets the counter channel's gate source as
 116     specified in data[2] (this is a hardware-specific value).  Not
 117     supported on PC214E.  For the other boards, valid gate sources are 0
 118     to 7 as follows:
 119
 120       0.  VCC (internal +5V d.c.), i.e. gate permanently enabled.
 121       1.  GND (internal 0V d.c.), i.e. gate permanently disabled.
 122       2.  GAT n, the counter channel's dedicated GAT input from the SK1
 123         connector.  (N.B. for other values, the counter channel's GATn
 124         pin on the SK1 connector is an output!)
 125       3.  /OUT n-2, the inverted output of counter channel n-2 (see note
 126         2 below).
 127       4.  Reserved.
 128       5.  Reserved.
 129       6.  Reserved.
 130       7.  Reserved.
 131
 132   INSN_CONFIG_GET_GATE_SRC.  Returns the counter channel's current gate
 133     source in data[2].
 134
 135 Clock and gate interconnection notes:
 136
 137   1.  Clock source OUT n-1 is the output of the preceding channel on the
 138   same counter subdevice if n > 0, or the output of channel 2 on the
 139   preceding counter subdevice (see note 3) if n = 0.
 140
 141   2.  Gate source /OUT n-2 is the inverted output of channel 0 on the
 142   same counter subdevice if n = 2, or the inverted output of channel n+1
 143   on the preceding counter subdevice (see note 3) if n < 2.
 144
 145   3.  The counter subdevices are connected in a ring, so the highest
 146   counter subdevice precedes the lowest.
 147
 148 The 'INTERRUPT' subdevice pretends to be a digital input subdevice.  The
 149 digital inputs come from the interrupt status register.  The number of
 150 channels matches the number of interrupt sources.  The PC214E does not
 151 have an interrupt status register; see notes on 'INTERRUPT SOURCES'
 152 below.
 153
 154 INTERRUPT SOURCES
 155
 156                     PC218E         PC212E      PC215E/PCI215
 157                  -------------  -------------  -------------
 158   Sources              6              6              6
 159    0              CTR-X1-OUT      PPI-X-C0       PPI-X-C0
 160    1              CTR-X2-OUT      PPI-X-C3       PPI-X-C3
 161    2              CTR-Y1-OUT     CTR-Y1-OUT      PPI-Y-C0
 162    3              CTR-Y2-OUT     CTR-Y2-OUT      PPI-Y-C3
 163    4              CTR-Z1-OUT     CTR-Z1-OUT     CTR-Z1-OUT
 164    5              CTR-Z2-OUT     CTR-Z2-OUT     CTR-Z2-OUT
 165
 166                     PC214E      PC272E/PCI272
 167                  -------------  -------------
 168   Sources              1              6
 169    0               JUMPER-J5      PPI-X-C0
 170    1                              PPI-X-C3
 171    2                              PPI-Y-C0
 172    3                              PPI-Y-C3
 173    4                              PPI-Z-C0
 174    5                              PPI-Z-C3
 175
 176 When an interrupt source is enabled in the interrupt source enable
 177 register, a rising edge on the source signal latches the corresponding
 178 bit to 1 in the interrupt status register.
 179
 180 When the interrupt status register value as a whole (actually, just the
 181 6 least significant bits) goes from zero to non-zero, the board will
 182 generate an interrupt.  For level-triggered hardware interrupts (PCI
 183 card), the interrupt will remain asserted until the interrupt status
 184 register is cleared to zero.  For edge-triggered hardware interrupts
 185 (ISA card), no further interrupts will occur until the interrupt status
 186 register is cleared to zero.  To clear a bit to zero in the interrupt
 187 status register, the corresponding interrupt source must be disabled
 188 in the interrupt source enable register (there is no separate interrupt
 189 clear register).
 190
 191 The PC214E does not have an interrupt source enable register or an
 192 interrupt status register; its 'INTERRUPT' subdevice has a single
 193 channel and its interrupt source is selected by the position of jumper
 194 J5.
 195
 196 COMMANDS
 197
 198 The driver supports a read streaming acquisition command on the
 199 'INTERRUPT' subdevice.  The channel list selects the interrupt sources
 200 to be enabled.  All channels will be sampled together (convert_src ==
 201 TRIG_NOW).  The scan begins a short time after the hardware interrupt
 202 occurs, subject to interrupt latencies (scan_begin_src == TRIG_EXT,
 203 scan_begin_arg == 0).  The value read from the interrupt status register
 204 is packed into a short value, one bit per requested channel, in the
 205 order they appear in the channel list.
 206 */
 207
 208 #include <linux/interrupt.h>
 209 #include <linux/slab.h>
 210
 211 #include "../comedidev.h"
 212
 213 #include "comedi_fc.h"
 214 #include "8255.h"
 215 #include "8253.h"
 216
 217 #define DIO200_DRIVER_NAME      "amplc_dio200"
 218
 219 #define DO_ISA  IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA)
 220 #define DO_PCI  IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI)
 221
 222 /* PCI IDs */
 223 #define PCI_VENDOR_ID_AMPLICON 0x14dc
 224 #define PCI_DEVICE_ID_AMPLICON_PCI272 0x000a
 225 #define PCI_DEVICE_ID_AMPLICON_PCI215 0x000b
 226 #define PCI_DEVICE_ID_INVALID 0xffff
 227
 228 /* 200 series registers */
 229 #define DIO200_IO_SIZE          0x20
 230 #define DIO200_XCLK_SCE         0x18    /* Group X clock selection register */
 231 #define DIO200_YCLK_SCE         0x19    /* Group Y clock selection register */
 232 #define DIO200_ZCLK_SCE         0x1a    /* Group Z clock selection register */
 233 #define DIO200_XGAT_SCE         0x1b    /* Group X gate selection register */
 234 #define DIO200_YGAT_SCE         0x1c    /* Group Y gate selection register */
 235 #define DIO200_ZGAT_SCE         0x1d    /* Group Z gate selection register */
 236 #define DIO200_INT_SCE          0x1e    /* Interrupt enable/status register */
 237
 238 /*
 239  * Macros for constructing value for DIO_200_?CLK_SCE and
 240  * DIO_200_?GAT_SCE registers:
 241  *
 242  * 'which' is: 0 for CTR-X1, CTR-Y1, CTR-Z1; 1 for CTR-X2, CTR-Y2 or CTR-Z2.
 243  * 'chan' is the channel: 0, 1 or 2.
 244  * 'source' is the signal source: 0 to 7.
 245  */
 246 #define CLK_SCE(which, chan, source) (((which) << 5) | ((chan) << 3) | (source))
 247 #define GAT_SCE(which, chan, source) (((which) << 5) | ((chan) << 3) | (source))
 248
 249 /*
 250  * Periods of the internal clock sources in nanoseconds.
 251  */
 252 static const unsigned clock_period[8] = {
 253         0,                      /* dedicated clock input/output pin */
 254         100,                    /* 10 MHz */
 255         1000,                   /* 1 MHz */
 256         10000,                  /* 100 kHz */
 257         100000,                 /* 10 kHz */
 258         1000000,                /* 1 kHz */
 259         0,                      /* OUT N-1 */
 260         0                       /* group clock input pin */
 261 };
 262
 263 /*
 264  * Board descriptions.
 265  */
 266
 267 enum dio200_bustype { isa_bustype, pci_bustype };
 268
 269 enum dio200_model {
 270         pc212e_model,
 271         pc214e_model,
 272         pc215e_model, pci215_model,
 273         pc218e_model,
 274         pc272e_model, pci272_model,
 275         anypci_model
 276 };
 277
 278 enum dio200_layout {
 279 #if DO_ISA
 280         pc212_layout,
 281         pc214_layout,
 282 #endif
 283         pc215_layout,
 284 #if DO_ISA
 285         pc218_layout,
 286 #endif
 287         pc272_layout
 288 };
 289
 290 struct dio200_board {
 291         const char *name;
 292         unsigned short devid;
 293         enum dio200_bustype bustype;
 294         enum dio200_model model;
 295         enum dio200_layout layout;
 296 };
 297
 298 static const struct dio200_board dio200_boards[] = {
 299 #if DO_ISA
 300         {
 301          .name = "pc212e",
 302          .bustype = isa_bustype,
 303          .model = pc212e_model,
 304          .layout = pc212_layout,
 305          },
 306         {
 307          .name = "pc214e",
 308          .bustype = isa_bustype,
 309          .model = pc214e_model,
 310          .layout = pc214_layout,
 311          },
 312         {
 313          .name = "pc215e",
 314          .bustype = isa_bustype,
 315          .model = pc215e_model,
 316          .layout = pc215_layout,
 317          },
 318         {
 319          .name = "pc218e",
 320          .bustype = isa_bustype,
 321          .model = pc218e_model,
 322          .layout = pc218_layout,
 323          },
 324         {
 325          .name = "pc272e",
 326          .bustype = isa_bustype,
 327          .model = pc272e_model,
 328          .layout = pc272_layout,
 329          },
 330 #endif
 331 #if DO_PCI
 332         {
 333          .name = "pci215",
 334          .devid = PCI_DEVICE_ID_AMPLICON_PCI215,
 335          .bustype = pci_bustype,
 336          .model = pci215_model,
 337          .layout = pc215_layout,
 338          },
 339         {
 340          .name = "pci272",
 341          .devid = PCI_DEVICE_ID_AMPLICON_PCI272,
 342          .bustype = pci_bustype,
 343          .model = pci272_model,
 344          .layout = pc272_layout,
 345          },
 346         {
 347          .name = DIO200_DRIVER_NAME,
 348          .devid = PCI_DEVICE_ID_INVALID,
 349          .bustype = pci_bustype,
 350          .model = anypci_model, /* wildcard */
 351          },
 352 #endif
 353 };
 354
 355 /*
 356  * Layout descriptions - some ISA and PCI board descriptions share the same
 357  * layout.
 358  */
 359
 360 enum dio200_sdtype { sd_none, sd_intr, sd_8255, sd_8254 };
 361
 362 #define DIO200_MAX_SUBDEVS      7
 363 #define DIO200_MAX_ISNS         6
 364
 365 struct dio200_layout_struct {
 366         unsigned short n_subdevs;       /* number of subdevices */
 367         unsigned char sdtype[DIO200_MAX_SUBDEVS];       /* enum dio200_sdtype */
 368         unsigned char sdinfo[DIO200_MAX_SUBDEVS];       /* depends on sdtype */
 369         char has_int_sce;       /* has interrupt enable/status register */
 370         char has_clk_gat_sce;   /* has clock/gate selection registers */
 371 };
 372
 373 static const struct dio200_layout_struct dio200_layouts[] = {
 374 #if DO_ISA
 375         [pc212_layout] = {
 376                           .n_subdevs = 6,
 377                           .sdtype = {sd_8255, sd_8254, sd_8254, sd_8254,
 378                                      sd_8254,
 379                                      sd_intr},
 380                           .sdinfo = {0x00, 0x08, 0x0C, 0x10, 0x14,
 381                                      0x3F},
 382                           .has_int_sce = 1,
 383                           .has_clk_gat_sce = 1,
 384                           },
 385         [pc214_layout] = {
 386                           .n_subdevs = 4,
 387                           .sdtype = {sd_8255, sd_8255, sd_8254,
 388                                      sd_intr},
 389                           .sdinfo = {0x00, 0x08, 0x10, 0x01},
 390                           .has_int_sce = 0,
 391                           .has_clk_gat_sce = 0,
 392                           },
 393 #endif
 394         [pc215_layout] = {
 395                           .n_subdevs = 5,
 396                           .sdtype = {sd_8255, sd_8255, sd_8254,
 397                                      sd_8254,
 398                                      sd_intr},
 399                           .sdinfo = {0x00, 0x08, 0x10, 0x14, 0x3F},
 400                           .has_int_sce = 1,
 401                           .has_clk_gat_sce = 1,
 402                           },
 403 #if DO_ISA
 404         [pc218_layout] = {
 405                           .n_subdevs = 7,
 406                           .sdtype = {sd_8254, sd_8254, sd_8255, sd_8254,
 407                                      sd_8254,
 408                                      sd_intr},
 409                           .sdinfo = {0x00, 0x04, 0x08, 0x0C, 0x10,
 410                                      0x14,
 411                                      0x3F},
 412                           .has_int_sce = 1,
 413                           .has_clk_gat_sce = 1,
 414                           },
 415 #endif
 416         [pc272_layout] = {
 417                           .n_subdevs = 4,
 418                           .sdtype = {sd_8255, sd_8255, sd_8255,
 419                                      sd_intr},
 420                           .sdinfo = {0x00, 0x08, 0x10, 0x3F},
 421                           .has_int_sce = 1,
 422                           .has_clk_gat_sce = 0,
 423                           },
 424 };
 425
 426 /* this structure is for data unique to this hardware driver.  If
 427    several hardware drivers keep similar information in this structure,
 428    feel free to suggest moving the variable to the struct comedi_device struct.
 429  */
 430 struct dio200_private {
 431         int intr_sd;
 432 };
 433
 434 struct dio200_subdev_8254 {
 435         unsigned long iobase;   /* Counter base address */
 436         unsigned long clk_sce_iobase;   /* CLK_SCE base address */
 437         unsigned long gat_sce_iobase;   /* GAT_SCE base address */
 438         int which;              /* Bit 5 of CLK_SCE or GAT_SCE */
 439         int has_clk_gat_sce;
 440         unsigned clock_src[3];  /* Current clock sources */
 441         unsigned gate_src[3];   /* Current gate sources */
 442         spinlock_t spinlock;
 443 };
 444
 445 struct dio200_subdev_intr {
 446         unsigned long iobase;
 447         spinlock_t spinlock;
 448         int active;
 449         int has_int_sce;
 450         unsigned int valid_isns;
 451         unsigned int enabled_isns;
 452         unsigned int stopcount;
 453         int continuous;
 454 };
 455
 456 static inline bool is_pci_board(const struct dio200_board *board)
 457 {
 458         return DO_PCI && board->bustype == pci_bustype;
 459 }
 460
 461 static inline bool is_isa_board(const struct dio200_board *board)
 462 {
 463         return DO_ISA && board->bustype == isa_bustype;
 464 }
 465
 466 /*
 467  * This function looks for a board matching the supplied PCI device.
 468  */
 469 static const struct dio200_board *
 470 dio200_find_pci_board(struct pci_dev *pci_dev)
 471 {
 472         unsigned int i;
 473
 474         for (i = 0; i < ARRAY_SIZE(dio200_boards); i++)
 475                 if (is_pci_board(&dio200_boards[i]) &&
 476                     pci_dev->device == dio200_boards[i].devid)
 477                         return &dio200_boards[i];
 478         return NULL;
 479 }
 480
 481 /*
 482  * This function looks for a PCI device matching the requested board name,
 483  * bus and slot.
 484  */
 485 static struct pci_dev *dio200_find_pci_dev(struct comedi_device *dev,
 486                                            struct comedi_devconfig *it)
 487 {
 488         const struct dio200_board *thisboard = comedi_board(dev);
 489         struct pci_dev *pci_dev = NULL;
 490         int bus = it->options[0];
 491         int slot = it->options[1];
 492
 493         for_each_pci_dev(pci_dev) {
 494                 if (bus || slot) {
 495                         if (bus != pci_dev->bus->number ||
 496                             slot != PCI_SLOT(pci_dev->devfn))
 497                                 continue;
 498                 }
 499                 if (pci_dev->vendor != PCI_VENDOR_ID_AMPLICON)
 500                         continue;
 501
 502                 if (thisboard->model == anypci_model) {
 503                         /* Wildcard board matches any supported PCI board. */
 504                         const struct dio200_board *foundboard;
 505
 506                         foundboard = dio200_find_pci_board(pci_dev);
 507                         if (foundboard == NULL)
 508                                 continue;
 509                         /* Replace wildcard board_ptr. */
 510                         dev->board_ptr = foundboard;
 511                 } else {
 512                         /* Match specific model name. */
 513                         if (pci_dev->device != thisboard->devid)
 514                                 continue;
 515                 }
 516                 return pci_dev;
 517         }
 518         dev_err(dev->class_dev,
 519                 "No supported board found! (req. bus %d, slot %d)\n",
 520                 bus, slot);
 521         return NULL;
 522 }
 523
 524 /*
 525  * This function checks and requests an I/O region, reporting an error
 526  * if there is a conflict.
 527  */
 528 static int
 529 dio200_request_region(struct comedi_device *dev,
 530                       unsigned long from, unsigned long extent)
 531 {
 532         if (!from || !request_region(from, extent, DIO200_DRIVER_NAME)) {
 533                 dev_err(dev->class_dev, "I/O port conflict (%#lx,%lu)!\n",
 534                         from, extent);
 535                 return -EIO;
 536         }
 537         return 0;
 538 }
 539
 540 /*
 541  * 'insn_bits' function for an 'INTERRUPT' subdevice.
 542  */
 543 static int
 544 dio200_subdev_intr_insn_bits(struct comedi_device *dev,
 545                              struct comedi_subdevice *s,
 546                              struct comedi_insn *insn, unsigned int *data)
 547 {
 548         struct dio200_subdev_intr *subpriv = s->private;
 549
 550         if (subpriv->has_int_sce) {
 551                 /* Just read the interrupt status register.  */
 552                 data[1] = inb(subpriv->iobase) & subpriv->valid_isns;
 553         } else {
 554                 /* No interrupt status register. */
 555                 data[0] = 0;
 556         }
 557
 558         return insn->n;
 559 }
 560
 561 /*
 562  * Called to stop acquisition for an 'INTERRUPT' subdevice.
 563  */
 564 static void dio200_stop_intr(struct comedi_device *dev,
 565                              struct comedi_subdevice *s)
 566 {
 567         struct dio200_subdev_intr *subpriv = s->private;
 568
 569         subpriv->active = 0;
 570         subpriv->enabled_isns = 0;
 571         if (subpriv->has_int_sce)
 572                 outb(0, subpriv->iobase);
 573 }
 574
 575 /*
 576  * Called to start acquisition for an 'INTERRUPT' subdevice.
 577  */
 578 static int dio200_start_intr(struct comedi_device *dev,
 579                              struct comedi_subdevice *s)
 580 {
 581         unsigned int n;
 582         unsigned isn_bits;
 583         struct dio200_subdev_intr *subpriv = s->private;
 584         struct comedi_cmd *cmd = &s->async->cmd;
 585         int retval = 0;
 586
 587         if (!subpriv->continuous && subpriv->stopcount == 0) {
 588                 /* An empty acquisition! */
 589                 s->async->events |= COMEDI_CB_EOA;
 590                 subpriv->active = 0;
 591                 retval = 1;
 592         } else {
 593                 /* Determine interrupt sources to enable. */
 594                 isn_bits = 0;
 595                 if (cmd->chanlist) {
 596                         for (n = 0; n < cmd->chanlist_len; n++)
 597                                 isn_bits |= (1U << CR_CHAN(cmd->chanlist[n]));
 598                 }
 599                 isn_bits &= subpriv->valid_isns;
 600                 /* Enable interrupt sources. */
 601                 subpriv->enabled_isns = isn_bits;
 602                 if (subpriv->has_int_sce)
 603                         outb(isn_bits, subpriv->iobase);
 604         }
 605
 606         return retval;
 607 }
 608
 609 /*
 610  * Internal trigger function to start acquisition for an 'INTERRUPT' subdevice.
 611  */
 612 static int
 613 dio200_inttrig_start_intr(struct comedi_device *dev, struct comedi_subdevice *s,
 614                           unsigned int trignum)
 615 {
 616         struct dio200_subdev_intr *subpriv;
 617         unsigned long flags;
 618         int event = 0;
 619
 620         if (trignum != 0)
 621                 return -EINVAL;
 622
 623         subpriv = s->private;
 624
 625         spin_lock_irqsave(&subpriv->spinlock, flags);
 626         s->async->inttrig = NULL;
 627         if (subpriv->active)
 628                 event = dio200_start_intr(dev, s);
 629
 630         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 631
 632         if (event)
 633                 comedi_event(dev, s);
 634
 635         return 1;
 636 }
 637
 638 /*
 639  * This is called from the interrupt service routine to handle a read
 640  * scan on an 'INTERRUPT' subdevice.
 641  */
 642 static int dio200_handle_read_intr(struct comedi_device *dev,
 643                                    struct comedi_subdevice *s)
 644 {
 645         struct dio200_subdev_intr *subpriv = s->private;
 646         unsigned triggered;
 647         unsigned intstat;
 648         unsigned cur_enabled;
 649         unsigned int oldevents;
 650         unsigned long flags;
 651
 652         triggered = 0;
 653
 654         spin_lock_irqsave(&subpriv->spinlock, flags);
 655         oldevents = s->async->events;
 656         if (subpriv->has_int_sce) {
 657                 /*
 658                  * Collect interrupt sources that have triggered and disable
 659                  * them temporarily.  Loop around until no extra interrupt
 660                  * sources have triggered, at which point, the valid part of
 661                  * the interrupt status register will read zero, clearing the
 662                  * cause of the interrupt.
 663                  *
 664                  * Mask off interrupt sources already seen to avoid infinite
 665                  * loop in case of misconfiguration.
 666                  */
 667                 cur_enabled = subpriv->enabled_isns;
 668                 while ((intstat = (inb(subpriv->iobase) & subpriv->valid_isns
 669                                    & ~triggered)) != 0) {
 670                         triggered |= intstat;
 671                         cur_enabled &= ~triggered;
 672                         outb(cur_enabled, subpriv->iobase);
 673                 }
 674         } else {
 675                 /*
 676                  * No interrupt status register.  Assume the single interrupt
 677                  * source has triggered.
 678                  */
 679                 triggered = subpriv->enabled_isns;
 680         }
 681
 682         if (triggered) {
 683                 /*
 684                  * Some interrupt sources have triggered and have been
 685                  * temporarily disabled to clear the cause of the interrupt.
 686                  *
 687                  * Reenable them NOW to minimize the time they are disabled.
 688                  */
 689                 cur_enabled = subpriv->enabled_isns;
 690                 if (subpriv->has_int_sce)
 691                         outb(cur_enabled, subpriv->iobase);
 692
 693                 if (subpriv->active) {
 694                         /*
 695                          * The command is still active.
 696                          *
 697                          * Ignore interrupt sources that the command isn't
 698                          * interested in (just in case there's a race
 699                          * condition).
 700                          */
 701                         if (triggered & subpriv->enabled_isns) {
 702                                 /* Collect scan data. */
 703                                 short val;
 704                                 unsigned int n, ch, len;
 705
 706                                 val = 0;
 707                                 len = s->async->cmd.chanlist_len;
 708                                 for (n = 0; n < len; n++) {
 709                                         ch = CR_CHAN(s->async->cmd.chanlist[n]);
 710                                         if (triggered & (1U << ch))
 711                                                 val |= (1U << n);
 712                                 }
 713                                 /* Write the scan to the buffer. */
 714                                 if (comedi_buf_put(s->async, val)) {
 715                                         s->async->events |= (COMEDI_CB_BLOCK |
 716                                                              COMEDI_CB_EOS);
 717                                 } else {
 718                                         /* Error!  Stop acquisition.  */
 719                                         dio200_stop_intr(dev, s);
 720                                         s->async->events |= COMEDI_CB_ERROR
 721                                             | COMEDI_CB_OVERFLOW;
 722                                         comedi_error(dev, "buffer overflow");
 723                                 }
 724
 725                                 /* Check for end of acquisition. */
 726                                 if (!subpriv->continuous) {
 727                                         /* stop_src == TRIG_COUNT */
 728                                         if (subpriv->stopcount > 0) {
 729                                                 subpriv->stopcount--;
 730                                                 if (subpriv->stopcount == 0) {
 731                                                         s->async->events |=
 732                                                             COMEDI_CB_EOA;
 733                                                         dio200_stop_intr(dev,
 734                                                                          s);
 735                                                 }
 736                                         }
 737                                 }
 738                         }
 739                 }
 740         }
 741         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 742
 743         if (oldevents != s->async->events)
 744                 comedi_event(dev, s);
 745
 746         return (triggered != 0);
 747 }
 748
 749 /*
 750  * 'cancel' function for an 'INTERRUPT' subdevice.
 751  */
 752 static int dio200_subdev_intr_cancel(struct comedi_device *dev,
 753                                      struct comedi_subdevice *s)
 754 {
 755         struct dio200_subdev_intr *subpriv = s->private;
 756         unsigned long flags;
 757
 758         spin_lock_irqsave(&subpriv->spinlock, flags);
 759         if (subpriv->active)
 760                 dio200_stop_intr(dev, s);
 761
 762         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 763
 764         return 0;
 765 }
 766
 767 /*
 768  * 'do_cmdtest' function for an 'INTERRUPT' subdevice.
 769  */
 770 static int
 771 dio200_subdev_intr_cmdtest(struct comedi_device *dev,
 772                            struct comedi_subdevice *s, struct comedi_cmd *cmd)
 773 {
 774         int err = 0;
 775
 776         /* Step 1 : check if triggers are trivially valid */
 777
 778         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
 779         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
 780         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 781         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 782         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 783
 784         if (err)
 785                 return 1;
 786
 787         /* Step 2a : make sure trigger sources are unique */
 788
 789         err |= cfc_check_trigger_is_unique(cmd->start_src);
 790         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 791
 792         /* Step 2b : and mutually compatible */
 793
 794         if (err)
 795                 return 2;
 796
 797         /* step 3: make sure arguments are trivially compatible */
 798
 799         /* cmd->start_src == TRIG_NOW || cmd->start_src == TRIG_INT */
 800         if (cmd->start_arg != 0) {
 801                 cmd->start_arg = 0;
 802                 err++;
 803         }
 804
 805         /* cmd->scan_begin_src == TRIG_EXT */
 806         if (cmd->scan_begin_arg != 0) {
 807                 cmd->scan_begin_arg = 0;
 808                 err++;
 809         }
 810
 811         /* cmd->convert_src == TRIG_NOW */
 812         if (cmd->convert_arg != 0) {
 813                 cmd->convert_arg = 0;
 814                 err++;
 815         }
 816
 817         /* cmd->scan_end_src == TRIG_COUNT */
 818         if (cmd->scan_end_arg != cmd->chanlist_len) {
 819                 cmd->scan_end_arg = cmd->chanlist_len;
 820                 err++;
 821         }
 822
 823         switch (cmd->stop_src) {
 824         case TRIG_COUNT:
 825                 /* any count allowed */
 826                 break;
 827         case TRIG_NONE:
 828                 if (cmd->stop_arg != 0) {
 829                         cmd->stop_arg = 0;
 830                         err++;
 831                 }
 832                 break;
 833         default:
 834                 break;
 835         }
 836
 837         if (err)
 838                 return 3;
 839
 840         /* step 4: fix up any arguments */
 841
 842         /* if (err) return 4; */
 843
 844         return 0;
 845 }
 846
 847 /*
 848  * 'do_cmd' function for an 'INTERRUPT' subdevice.
 849  */
 850 static int dio200_subdev_intr_cmd(struct comedi_device *dev,
 851                                   struct comedi_subdevice *s)
 852 {
 853         struct comedi_cmd *cmd = &s->async->cmd;
 854         struct dio200_subdev_intr *subpriv = s->private;
 855         unsigned long flags;
 856         int event = 0;
 857
 858         spin_lock_irqsave(&subpriv->spinlock, flags);
 859         subpriv->active = 1;
 860
 861         /* Set up end of acquisition. */
 862         switch (cmd->stop_src) {
 863         case TRIG_COUNT:
 864                 subpriv->continuous = 0;
 865                 subpriv->stopcount = cmd->stop_arg;
 866                 break;
 867         default:
 868                 /* TRIG_NONE */
 869                 subpriv->continuous = 1;
 870                 subpriv->stopcount = 0;
 871                 break;
 872         }
 873
 874         /* Set up start of acquisition. */
 875         switch (cmd->start_src) {
 876         case TRIG_INT:
 877                 s->async->inttrig = dio200_inttrig_start_intr;
 878                 break;
 879         default:
 880                 /* TRIG_NOW */
 881                 event = dio200_start_intr(dev, s);
 882                 break;
 883         }
 884         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 885
 886         if (event)
 887                 comedi_event(dev, s);
 888
 889         return 0;
 890 }
 891
 892 /*
 893  * This function initializes an 'INTERRUPT' subdevice.
 894  */
 895 static int
 896 dio200_subdev_intr_init(struct comedi_device *dev, struct comedi_subdevice *s,
 897                         unsigned long iobase, unsigned valid_isns,
 898                         int has_int_sce)
 899 {
 900         struct dio200_subdev_intr *subpriv;
 901
 902         subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
 903         if (!subpriv) {
 904                 dev_err(dev->class_dev, "error! out of memory!\n");
 905                 return -ENOMEM;
 906         }
 907         subpriv->iobase = iobase;
 908         subpriv->has_int_sce = has_int_sce;
 909         subpriv->valid_isns = valid_isns;
 910         spin_lock_init(&subpriv->spinlock);
 911
 912         if (has_int_sce)
 913                 outb(0, subpriv->iobase);       /* Disable interrupt sources. */
 914
 915         s->private = subpriv;
 916         s->type = COMEDI_SUBD_DI;
 917         s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
 918         if (has_int_sce) {
 919                 s->n_chan = DIO200_MAX_ISNS;
 920                 s->len_chanlist = DIO200_MAX_ISNS;
 921         } else {
 922                 /* No interrupt source register.  Support single channel. */
 923                 s->n_chan = 1;
 924                 s->len_chanlist = 1;
 925         }
 926         s->range_table = &range_digital;
 927         s->maxdata = 1;
 928         s->insn_bits = dio200_subdev_intr_insn_bits;
 929         s->do_cmdtest = dio200_subdev_intr_cmdtest;
 930         s->do_cmd = dio200_subdev_intr_cmd;
 931         s->cancel = dio200_subdev_intr_cancel;
 932
 933         return 0;
 934 }
 935
 936 /*
 937  * This function cleans up an 'INTERRUPT' subdevice.
 938  */
 939 static void
 940 dio200_subdev_intr_cleanup(struct comedi_device *dev,
 941                            struct comedi_subdevice *s)
 942 {
 943         struct dio200_subdev_intr *subpriv = s->private;
 944         kfree(subpriv);
 945 }
 946
 947 /*
 948  * Interrupt service routine.
 949  */
 950 static irqreturn_t dio200_interrupt(int irq, void *d)
 951 {
 952         struct comedi_device *dev = d;
 953         struct dio200_private *devpriv = dev->private;
 954         struct comedi_subdevice *s;
 955         int handled;
 956
 957         if (!dev->attached)
 958                 return IRQ_NONE;
 959
 960         if (devpriv->intr_sd >= 0) {
 961                 s = &dev->subdevices[devpriv->intr_sd];
 962                 handled = dio200_handle_read_intr(dev, s);
 963         } else {
 964                 handled = 0;
 965         }
 966
 967         return IRQ_RETVAL(handled);
 968 }
 969
 970 /*
 971  * Handle 'insn_read' for an '8254' counter subdevice.
 972  */
 973 static int
 974 dio200_subdev_8254_read(struct comedi_device *dev, struct comedi_subdevice *s,
 975                         struct comedi_insn *insn, unsigned int *data)
 976 {
 977         struct dio200_subdev_8254 *subpriv = s->private;
 978         int chan = CR_CHAN(insn->chanspec);
 979         unsigned long flags;
 980
 981         spin_lock_irqsave(&subpriv->spinlock, flags);
 982         data[0] = i8254_read(subpriv->iobase, 0, chan);
 983         spin_unlock_irqrestore(&subpriv->spinlock, flags);
 984
 985         return 1;
 986 }
 987
 988 /*
 989  * Handle 'insn_write' for an '8254' counter subdevice.
 990  */
 991 static int
 992 dio200_subdev_8254_write(struct comedi_device *dev, struct comedi_subdevice *s,
 993                          struct comedi_insn *insn, unsigned int *data)
 994 {
 995         struct dio200_subdev_8254 *subpriv = s->private;
 996         int chan = CR_CHAN(insn->chanspec);
 997         unsigned long flags;
 998
 999         spin_lock_irqsave(&subpriv->spinlock, flags);
1000         i8254_write(subpriv->iobase, 0, chan, data[0]);
1001         spin_unlock_irqrestore(&subpriv->spinlock, flags);
1002
1003         return 1;
1004 }
1005
1006 /*
1007  * Set gate source for an '8254' counter subdevice channel.
1008  */
1009 static int
1010 dio200_set_gate_src(struct dio200_subdev_8254 *subpriv,
1011                     unsigned int counter_number, unsigned int gate_src)
1012 {
1013         unsigned char byte;
1014
1015         if (!subpriv->has_clk_gat_sce)
1016                 return -1;
1017         if (counter_number > 2)
1018                 return -1;
1019         if (gate_src > 7)
1020                 return -1;
1021
1022         subpriv->gate_src[counter_number] = gate_src;
1023         byte = GAT_SCE(subpriv->which, counter_number, gate_src);
1024         outb(byte, subpriv->gat_sce_iobase);
1025
1026         return 0;
1027 }
1028
1029 /*
1030  * Get gate source for an '8254' counter subdevice channel.
1031  */
1032 static int
1033 dio200_get_gate_src(struct dio200_subdev_8254 *subpriv,
1034                     unsigned int counter_number)
1035 {
1036         if (!subpriv->has_clk_gat_sce)
1037                 return -1;
1038         if (counter_number > 2)
1039                 return -1;
1040
1041         return subpriv->gate_src[counter_number];
1042 }
1043
1044 /*
1045  * Set clock source for an '8254' counter subdevice channel.
1046  */
1047 static int
1048 dio200_set_clock_src(struct dio200_subdev_8254 *subpriv,
1049                      unsigned int counter_number, unsigned int clock_src)
1050 {
1051         unsigned char byte;
1052
1053         if (!subpriv->has_clk_gat_sce)
1054                 return -1;
1055         if (counter_number > 2)
1056                 return -1;
1057         if (clock_src > 7)
1058                 return -1;
1059
1060         subpriv->clock_src[counter_number] = clock_src;
1061         byte = CLK_SCE(subpriv->which, counter_number, clock_src);
1062         outb(byte, subpriv->clk_sce_iobase);
1063
1064         return 0;
1065 }
1066
1067 /*
1068  * Get clock source for an '8254' counter subdevice channel.
1069  */
1070 static int
1071 dio200_get_clock_src(struct dio200_subdev_8254 *subpriv,
1072                      unsigned int counter_number, unsigned int *period_ns)
1073 {
1074         unsigned clock_src;
1075
1076         if (!subpriv->has_clk_gat_sce)
1077                 return -1;
1078         if (counter_number > 2)
1079                 return -1;
1080
1081         clock_src = subpriv->clock_src[counter_number];
1082         *period_ns = clock_period[clock_src];
1083         return clock_src;
1084 }
1085
1086 /*
1087  * Handle 'insn_config' for an '8254' counter subdevice.
1088  */
1089 static int
1090 dio200_subdev_8254_config(struct comedi_device *dev, struct comedi_subdevice *s,
1091                           struct comedi_insn *insn, unsigned int *data)
1092 {
1093         struct dio200_subdev_8254 *subpriv = s->private;
1094         int ret = 0;
1095         int chan = CR_CHAN(insn->chanspec);
1096         unsigned long flags;
1097
1098         spin_lock_irqsave(&subpriv->spinlock, flags);
1099         switch (data[0]) {
1100         case INSN_CONFIG_SET_COUNTER_MODE:
1101                 ret = i8254_set_mode(subpriv->iobase, 0, chan, data[1]);
1102                 if (ret < 0)
1103                         ret = -EINVAL;
1104                 break;
1105         case INSN_CONFIG_8254_READ_STATUS:
1106                 data[1] = i8254_status(subpriv->iobase, 0, chan);
1107                 break;
1108         case INSN_CONFIG_SET_GATE_SRC:
1109                 ret = dio200_set_gate_src(subpriv, chan, data[2]);
1110                 if (ret < 0)
1111                         ret = -EINVAL;
1112                 break;
1113         case INSN_CONFIG_GET_GATE_SRC:
1114                 ret = dio200_get_gate_src(subpriv, chan);
1115                 if (ret < 0) {
1116                         ret = -EINVAL;
1117                         break;
1118                 }
1119                 data[2] = ret;
1120                 break;
1121         case INSN_CONFIG_SET_CLOCK_SRC:
1122                 ret = dio200_set_clock_src(subpriv, chan, data[1]);
1123                 if (ret < 0)
1124                         ret = -EINVAL;
1125                 break;
1126         case INSN_CONFIG_GET_CLOCK_SRC:
1127                 ret = dio200_get_clock_src(subpriv, chan, &data[2]);
1128                 if (ret < 0) {
1129                         ret = -EINVAL;
1130                         break;
1131                 }
1132                 data[1] = ret;
1133                 break;
1134         default:
1135                 ret = -EINVAL;
1136                 break;
1137         }
1138         spin_unlock_irqrestore(&subpriv->spinlock, flags);
1139         return ret < 0 ? ret : insn->n;
1140 }
1141
1142 /*
1143  * This function initializes an '8254' counter subdevice.
1144  *
1145  * Note: iobase is the base address of the board, not the subdevice;
1146  * offset is the offset to the 8254 chip.
1147  */
1148 static int
1149 dio200_subdev_8254_init(struct comedi_device *dev, struct comedi_subdevice *s,
1150                         unsigned long iobase, unsigned offset,
1151                         int has_clk_gat_sce)
1152 {
1153         struct dio200_subdev_8254 *subpriv;
1154         unsigned int chan;
1155
1156         subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
1157         if (!subpriv) {
1158                 dev_err(dev->class_dev, "error! out of memory!\n");
1159                 return -ENOMEM;
1160         }
1161
1162         s->private = subpriv;
1163         s->type = COMEDI_SUBD_COUNTER;
1164         s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
1165         s->n_chan = 3;
1166         s->maxdata = 0xFFFF;
1167         s->insn_read = dio200_subdev_8254_read;
1168         s->insn_write = dio200_subdev_8254_write;
1169         s->insn_config = dio200_subdev_8254_config;
1170
1171         spin_lock_init(&subpriv->spinlock);
1172         subpriv->iobase = offset + iobase;
1173         subpriv->has_clk_gat_sce = has_clk_gat_sce;
1174         if (has_clk_gat_sce) {
1175                 /* Derive CLK_SCE and GAT_SCE register offsets from
1176                  * 8254 offset. */
1177                 subpriv->clk_sce_iobase =
1178                     DIO200_XCLK_SCE + (offset >> 3) + iobase;
1179                 subpriv->gat_sce_iobase =
1180                     DIO200_XGAT_SCE + (offset >> 3) + iobase;
1181                 subpriv->which = (offset >> 2) & 1;
1182         }
1183
1184         /* Initialize channels. */
1185         for (chan = 0; chan < 3; chan++) {
1186                 i8254_set_mode(subpriv->iobase, 0, chan,
1187                                I8254_MODE0 | I8254_BINARY);
1188                 if (subpriv->has_clk_gat_sce) {
1189                         /* Gate source 0 is VCC (logic 1). */
1190                         dio200_set_gate_src(subpriv, chan, 0);
1191                         /* Clock source 0 is the dedicated clock input. */
1192                         dio200_set_clock_src(subpriv, chan, 0);
1193                 }
1194         }
1195
1196         return 0;
1197 }
1198
1199 /*
1200  * This function cleans up an '8254' counter subdevice.
1201  */
1202 static void
1203 dio200_subdev_8254_cleanup(struct comedi_device *dev,
1204                            struct comedi_subdevice *s)
1205 {
1206         struct dio200_subdev_intr *subpriv = s->private;
1207         kfree(subpriv);
1208 }
1209
1210 static void dio200_report_attach(struct comedi_device *dev, unsigned int irq)
1211 {
1212         const struct dio200_board *thisboard = comedi_board(dev);
1213         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1214         char tmpbuf[60];
1215         int tmplen;
1216
1217         if (is_isa_board(thisboard))
1218                 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
1219                                    "(base %#lx) ", dev->iobase);
1220         else if (is_pci_board(thisboard))
1221                 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
1222                                    "(pci %s) ", pci_name(pcidev));
1223         else
1224                 tmplen = 0;
1225         if (irq)
1226                 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
1227                                     "(irq %u%s) ", irq,
1228                                     (dev->irq ? "" : " UNAVAILABLE"));
1229         else
1230                 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
1231                                     "(no irq) ");
1232         dev_info(dev->class_dev, "%s %sattached\n", dev->board_name, tmpbuf);
1233 }
1234
1235 static int dio200_common_attach(struct comedi_device *dev, unsigned long iobase,
1236                                 unsigned int irq, unsigned long req_irq_flags)
1237 {
1238         const struct dio200_board *thisboard = comedi_board(dev);
1239         struct dio200_private *devpriv = dev->private;
1240         const struct dio200_layout_struct *layout =
1241                 &dio200_layouts[thisboard->layout];
1242         struct comedi_subdevice *s;
1243         int sdx;
1244         unsigned int n;
1245         int ret;
1246
1247         devpriv->intr_sd = -1;
1248         dev->iobase = iobase;
1249         dev->board_name = thisboard->name;
1250
1251         ret = comedi_alloc_subdevices(dev, layout->n_subdevs);
1252         if (ret)
1253                 return ret;
1254
1255         for (n = 0; n < dev->n_subdevices; n++) {
1256                 s = &dev->subdevices[n];
1257                 switch (layout->sdtype[n]) {
1258                 case sd_8254:
1259                         /* counter subdevice (8254) */
1260                         ret = dio200_subdev_8254_init(dev, s, iobase,
1261                                                       layout->sdinfo[n],
1262                                                       layout->has_clk_gat_sce);
1263                         if (ret < 0)
1264                                 return ret;
1265                         break;
1266                 case sd_8255:
1267                         /* digital i/o subdevice (8255) */
1268                         ret = subdev_8255_init(dev, s, NULL,
1269                                                iobase + layout->sdinfo[n]);
1270                         if (ret < 0)
1271                                 return ret;
1272                         break;
1273                 case sd_intr:
1274                         /* 'INTERRUPT' subdevice */
1275                         if (irq) {
1276                                 ret = dio200_subdev_intr_init(dev, s,
1277                                                               iobase +
1278                                                               DIO200_INT_SCE,
1279                                                               layout->sdinfo[n],
1280                                                               layout->
1281                                                               has_int_sce);
1282                                 if (ret < 0)
1283                                         return ret;
1284                                 devpriv->intr_sd = n;
1285                         } else {
1286                                 s->type = COMEDI_SUBD_UNUSED;
1287                         }
1288                         break;
1289                 default:
1290                         s->type = COMEDI_SUBD_UNUSED;
1291                         break;
1292                 }
1293         }
1294         sdx = devpriv->intr_sd;
1295         if (sdx >= 0 && sdx < dev->n_subdevices)
1296                 dev->read_subdev = &dev->subdevices[sdx];
1297         if (irq) {
1298                 if (request_irq(irq, dio200_interrupt, req_irq_flags,
1299                                 DIO200_DRIVER_NAME, dev) >= 0) {
1300                         dev->irq = irq;
1301                 } else {
1302                         dev_warn(dev->class_dev,
1303                                  "warning! irq %u unavailable!\n", irq);
1304                 }
1305         }
1306         dio200_report_attach(dev, irq);
1307         return 1;
1308 }
1309
1310 static int dio200_pci_common_attach(struct comedi_device *dev,
1311                                     struct pci_dev *pci_dev)
1312 {
1313         unsigned long iobase;
1314         int ret;
1315
1316         comedi_set_hw_dev(dev, &pci_dev->dev);
1317
1318         ret = comedi_pci_enable(pci_dev, DIO200_DRIVER_NAME);
1319         if (ret < 0) {
1320                 dev_err(dev->class_dev,
1321                         "error! cannot enable PCI device and request regions!\n");
1322                 return ret;
1323         }
1324         iobase = pci_resource_start(pci_dev, 2);
1325         return dio200_common_attach(dev, iobase, pci_dev->irq, IRQF_SHARED);
1326 }
1327
1328 /*
1329  * Attach is called by the Comedi core to configure the driver
1330  * for a particular board.  If you specified a board_name array
1331  * in the driver structure, dev->board_ptr contains that
1332  * address.
1333  */
1334 static int dio200_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1335 {
1336         const struct dio200_board *thisboard = comedi_board(dev);
1337         int ret;
1338
1339         dev_info(dev->class_dev, DIO200_DRIVER_NAME ": attach\n");
1340
1341         ret = alloc_private(dev, sizeof(struct dio200_private));
1342         if (ret < 0) {
1343                 dev_err(dev->class_dev, "error! out of memory!\n");
1344                 return ret;
1345         }
1346
1347         /* Process options and reserve resources according to bus type. */
1348         if (is_isa_board(thisboard)) {
1349                 unsigned long iobase;
1350                 unsigned int irq;
1351
1352                 iobase = it->options[0];
1353                 irq = it->options[1];
1354                 ret = dio200_request_region(dev, iobase, DIO200_IO_SIZE);
1355                 if (ret < 0)
1356                         return ret;
1357                 return dio200_common_attach(dev, iobase, irq, 0);
1358         } else if (is_pci_board(thisboard)) {
1359                 struct pci_dev *pci_dev;
1360
1361                 pci_dev = dio200_find_pci_dev(dev, it);
1362                 if (!pci_dev)
1363                         return -EIO;
1364                 return dio200_pci_common_attach(dev, pci_dev);
1365         } else {
1366                 dev_err(dev->class_dev, DIO200_DRIVER_NAME
1367                         ": BUG! cannot determine board type!\n");
1368                 return -EINVAL;
1369         }
1370 }
1371
1372 /*
1373  * The attach_pci hook (if non-NULL) is called at PCI probe time in preference
1374  * to the "manual" attach hook.  dev->board_ptr is NULL on entry.  There should
1375  * be a board entry matching the supplied PCI device.
1376  */
1377 static int __devinit dio200_attach_pci(struct comedi_device *dev,
1378                                        struct pci_dev *pci_dev)
1379 {
1380         int ret;
1381
1382         if (!DO_PCI)
1383                 return -EINVAL;
1384
1385         dev_info(dev->class_dev, DIO200_DRIVER_NAME ": attach pci %s\n",
1386                  pci_name(pci_dev));
1387         ret = alloc_private(dev, sizeof(struct dio200_private));
1388         if (ret < 0) {
1389                 dev_err(dev->class_dev, "error! out of memory!\n");
1390                 return ret;
1391         }
1392         dev->board_ptr = dio200_find_pci_board(pci_dev);
1393         if (dev->board_ptr == NULL) {
1394                 dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
1395                 return -EINVAL;
1396         }
1397         /*
1398          * Need to 'get' the PCI device to match the 'put' in dio200_detach().
1399          * TODO: Remove the pci_dev_get() and matching pci_dev_put() once
1400          * support for manual attachment of PCI devices via dio200_attach()
1401          * has been removed.
1402          */
1403         pci_dev_get(pci_dev);
1404         return dio200_pci_common_attach(dev, pci_dev);
1405 }
1406
1407 static void dio200_detach(struct comedi_device *dev)
1408 {
1409         const struct dio200_board *thisboard = comedi_board(dev);
1410         const struct dio200_layout_struct *layout;
1411         unsigned n;
1412
1413         if (!thisboard)
1414                 return;
1415         if (dev->irq)
1416                 free_irq(dev->irq, dev);
1417         if (dev->subdevices) {
1418                 layout = &dio200_layouts[thisboard->layout];
1419                 for (n = 0; n < dev->n_subdevices; n++) {
1420                         struct comedi_subdevice *s = &dev->subdevices[n];
1421                         switch (layout->sdtype[n]) {
1422                         case sd_8254:
1423                                 dio200_subdev_8254_cleanup(dev, s);
1424                                 break;
1425                         case sd_8255:
1426                                 subdev_8255_cleanup(dev, s);
1427                                 break;
1428                         case sd_intr:
1429                                 dio200_subdev_intr_cleanup(dev, s);
1430                                 break;
1431                         default:
1432                                 break;
1433                         }
1434                 }
1435         }
1436         if (is_isa_board(thisboard)) {
1437                 if (dev->iobase)
1438                         release_region(dev->iobase, DIO200_IO_SIZE);
1439         } else if (is_pci_board(thisboard)) {
1440                 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1441                 if (pcidev) {
1442                         if (dev->iobase)
1443                                 comedi_pci_disable(pcidev);
1444                         pci_dev_put(pcidev);
1445                 }
1446         }
1447 }
1448
1449 /*
1450  * The struct comedi_driver structure tells the Comedi core module
1451  * which functions to call to configure/deconfigure (attach/detach)
1452  * the board, and also about the kernel module that contains
1453  * the device code.
1454  */
1455 static struct comedi_driver amplc_dio200_driver = {
1456         .driver_name = DIO200_DRIVER_NAME,
1457         .module = THIS_MODULE,
1458         .attach = dio200_attach,
1459         .attach_pci = dio200_attach_pci,
1460         .detach = dio200_detach,
1461         .board_name = &dio200_boards[0].name,
1462         .offset = sizeof(struct dio200_board),
1463         .num_names = ARRAY_SIZE(dio200_boards),
1464 };
1465
1466 #if DO_PCI
1467 static DEFINE_PCI_DEVICE_TABLE(dio200_pci_table) = {
1468         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI215) },
1469         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI272) },
1470         {0}
1471 };
1472
1473 MODULE_DEVICE_TABLE(pci, dio200_pci_table);
1474
1475 static int __devinit amplc_dio200_pci_probe(struct pci_dev *dev,
1476                                                    const struct pci_device_id
1477                                                    *ent)
1478 {
1479         return comedi_pci_auto_config(dev, &amplc_dio200_driver);
1480 }
1481
1482 static void __devexit amplc_dio200_pci_remove(struct pci_dev *dev)
1483 {
1484         comedi_pci_auto_unconfig(dev);
1485 }
1486
1487 static struct pci_driver amplc_dio200_pci_driver = {
1488         .name = DIO200_DRIVER_NAME,
1489         .id_table = dio200_pci_table,
1490         .probe = &amplc_dio200_pci_probe,
1491         .remove = __devexit_p(&amplc_dio200_pci_remove)
1492 };
1493 module_comedi_pci_driver(amplc_dio200_driver, amplc_dio200_pci_driver);
1494 #else
1495 module_comedi_driver(amplc_dio200_driver);
1496 #endif
1497
1498 MODULE_AUTHOR("Comedi http://www.comedi.org");
1499 MODULE_DESCRIPTION("Comedi low-level driver");
1500 MODULE_LICENSE("GPL");