drivers/staging/comedi/drivers/me4000.c

   1 /*
   2    comedi/drivers/me4000.c
   3    Source code for the Meilhaus ME-4000 board family.
   4
   5    COMEDI - Linux Control and Measurement Device Interface
   6    Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22  */
  23 /*
  24 Driver: me4000
  25 Description: Meilhaus ME-4000 series boards
  26 Devices: [Meilhaus] ME-4650 (me4000), ME-4670i, ME-4680, ME-4680i, ME-4680is
  27 Author: gg (Guenter Gebhardt <g.gebhardt@meilhaus.com>)
  28 Updated: Mon, 18 Mar 2002 15:34:01 -0800
  29 Status: broken (no support for loading firmware)
  30
  31 Supports:
  32
  33     - Analog Input
  34     - Analog Output
  35     - Digital I/O
  36     - Counter
  37
  38 Configuration Options: not applicable, uses PCI auto config
  39
  40 The firmware required by these boards is available in the
  41 comedi_nonfree_firmware tarball available from
  42 http://www.comedi.org.  However, the driver's support for
  43 loading the firmware through comedi_config is currently
  44 broken.
  45
  46  */
  47
  48 #include <linux/pci.h>
  49 #include <linux/delay.h>
  50 #include <linux/interrupt.h>
  51 #include <linux/list.h>
  52 #include <linux/spinlock.h>
  53
  54 #include "../comedidev.h"
  55
  56 #include "comedi_fc.h"
  57 #include "8253.h"
  58
  59 #if 0
  60 /* file removed due to GPL incompatibility */
  61 #include "me4000_fw.h"
  62 #endif
  63
  64 #define PCI_DEVICE_ID_MEILHAUS_ME4650   0x4650
  65 #define PCI_DEVICE_ID_MEILHAUS_ME4660   0x4660
  66 #define PCI_DEVICE_ID_MEILHAUS_ME4660I  0x4661
  67 #define PCI_DEVICE_ID_MEILHAUS_ME4660S  0x4662
  68 #define PCI_DEVICE_ID_MEILHAUS_ME4660IS 0x4663
  69 #define PCI_DEVICE_ID_MEILHAUS_ME4670   0x4670
  70 #define PCI_DEVICE_ID_MEILHAUS_ME4670I  0x4671
  71 #define PCI_DEVICE_ID_MEILHAUS_ME4670S  0x4672
  72 #define PCI_DEVICE_ID_MEILHAUS_ME4670IS 0x4673
  73 #define PCI_DEVICE_ID_MEILHAUS_ME4680   0x4680
  74 #define PCI_DEVICE_ID_MEILHAUS_ME4680I  0x4681
  75 #define PCI_DEVICE_ID_MEILHAUS_ME4680S  0x4682
  76 #define PCI_DEVICE_ID_MEILHAUS_ME4680IS 0x4683
  77
  78 /*
  79  * ME4000 Register map and bit defines
  80  */
  81 #define ME4000_AO_CHAN(x)                       ((x) * 0x18)
  82
  83 #define ME4000_AO_CTRL_REG(x)                   (0x00 + ME4000_AO_CHAN(x))
  84 #define ME4000_AO_CTRL_BIT_MODE_0               (1 << 0)
  85 #define ME4000_AO_CTRL_BIT_MODE_1               (1 << 1)
  86 #define ME4000_AO_CTRL_MASK_MODE                (3 << 0)
  87 #define ME4000_AO_CTRL_BIT_STOP                 (1 << 2)
  88 #define ME4000_AO_CTRL_BIT_ENABLE_FIFO          (1 << 3)
  89 #define ME4000_AO_CTRL_BIT_ENABLE_EX_TRIG       (1 << 4)
  90 #define ME4000_AO_CTRL_BIT_EX_TRIG_EDGE         (1 << 5)
  91 #define ME4000_AO_CTRL_BIT_IMMEDIATE_STOP       (1 << 7)
  92 #define ME4000_AO_CTRL_BIT_ENABLE_DO            (1 << 8)
  93 #define ME4000_AO_CTRL_BIT_ENABLE_IRQ           (1 << 9)
  94 #define ME4000_AO_CTRL_BIT_RESET_IRQ            (1 << 10)
  95 #define ME4000_AO_STATUS_REG(x)                 (0x04 + ME4000_AO_CHAN(x))
  96 #define ME4000_AO_STATUS_BIT_FSM                (1 << 0)
  97 #define ME4000_AO_STATUS_BIT_FF                 (1 << 1)
  98 #define ME4000_AO_STATUS_BIT_HF                 (1 << 2)
  99 #define ME4000_AO_STATUS_BIT_EF                 (1 << 3)
 100 #define ME4000_AO_FIFO_REG(x)                   (0x08 + ME4000_AO_CHAN(x))
 101 #define ME4000_AO_SINGLE_REG(x)                 (0x0c + ME4000_AO_CHAN(x))
 102 #define ME4000_AO_TIMER_REG(x)                  (0x10 + ME4000_AO_CHAN(x))
 103 #define ME4000_AI_CTRL_REG                      0x74
 104 #define ME4000_AI_STATUS_REG                    0x74
 105 #define ME4000_AI_CTRL_BIT_MODE_0               (1 << 0)
 106 #define ME4000_AI_CTRL_BIT_MODE_1               (1 << 1)
 107 #define ME4000_AI_CTRL_BIT_MODE_2               (1 << 2)
 108 #define ME4000_AI_CTRL_BIT_SAMPLE_HOLD          (1 << 3)
 109 #define ME4000_AI_CTRL_BIT_IMMEDIATE_STOP       (1 << 4)
 110 #define ME4000_AI_CTRL_BIT_STOP                 (1 << 5)
 111 #define ME4000_AI_CTRL_BIT_CHANNEL_FIFO         (1 << 6)
 112 #define ME4000_AI_CTRL_BIT_DATA_FIFO            (1 << 7)
 113 #define ME4000_AI_CTRL_BIT_FULLSCALE            (1 << 8)
 114 #define ME4000_AI_CTRL_BIT_OFFSET               (1 << 9)
 115 #define ME4000_AI_CTRL_BIT_EX_TRIG_ANALOG       (1 << 10)
 116 #define ME4000_AI_CTRL_BIT_EX_TRIG              (1 << 11)
 117 #define ME4000_AI_CTRL_BIT_EX_TRIG_FALLING      (1 << 12)
 118 #define ME4000_AI_CTRL_BIT_EX_IRQ               (1 << 13)
 119 #define ME4000_AI_CTRL_BIT_EX_IRQ_RESET         (1 << 14)
 120 #define ME4000_AI_CTRL_BIT_LE_IRQ               (1 << 15)
 121 #define ME4000_AI_CTRL_BIT_LE_IRQ_RESET         (1 << 16)
 122 #define ME4000_AI_CTRL_BIT_HF_IRQ               (1 << 17)
 123 #define ME4000_AI_CTRL_BIT_HF_IRQ_RESET         (1 << 18)
 124 #define ME4000_AI_CTRL_BIT_SC_IRQ               (1 << 19)
 125 #define ME4000_AI_CTRL_BIT_SC_IRQ_RESET         (1 << 20)
 126 #define ME4000_AI_CTRL_BIT_SC_RELOAD            (1 << 21)
 127 #define ME4000_AI_STATUS_BIT_EF_CHANNEL         (1 << 22)
 128 #define ME4000_AI_STATUS_BIT_HF_CHANNEL         (1 << 23)
 129 #define ME4000_AI_STATUS_BIT_FF_CHANNEL         (1 << 24)
 130 #define ME4000_AI_STATUS_BIT_EF_DATA            (1 << 25)
 131 #define ME4000_AI_STATUS_BIT_HF_DATA            (1 << 26)
 132 #define ME4000_AI_STATUS_BIT_FF_DATA            (1 << 27)
 133 #define ME4000_AI_STATUS_BIT_LE                 (1 << 28)
 134 #define ME4000_AI_STATUS_BIT_FSM                (1 << 29)
 135 #define ME4000_AI_CTRL_BIT_EX_TRIG_BOTH         (1 << 31)
 136 #define ME4000_AI_CHANNEL_LIST_REG              0x78
 137 #define ME4000_AI_LIST_INPUT_SINGLE_ENDED       (0 << 5)
 138 #define ME4000_AI_LIST_INPUT_DIFFERENTIAL       (1 << 5)
 139 #define ME4000_AI_LIST_RANGE_BIPOLAR_10         (0 << 6)
 140 #define ME4000_AI_LIST_RANGE_BIPOLAR_2_5        (1 << 6)
 141 #define ME4000_AI_LIST_RANGE_UNIPOLAR_10        (2 << 6)
 142 #define ME4000_AI_LIST_RANGE_UNIPOLAR_2_5       (3 << 6)
 143 #define ME4000_AI_LIST_LAST_ENTRY               (1 << 8)
 144 #define ME4000_AI_DATA_REG                      0x7c
 145 #define ME4000_AI_CHAN_TIMER_REG                0x80
 146 #define ME4000_AI_CHAN_PRE_TIMER_REG            0x84
 147 #define ME4000_AI_SCAN_TIMER_LOW_REG            0x88
 148 #define ME4000_AI_SCAN_TIMER_HIGH_REG           0x8c
 149 #define ME4000_AI_SCAN_PRE_TIMER_LOW_REG        0x90
 150 #define ME4000_AI_SCAN_PRE_TIMER_HIGH_REG       0x94
 151 #define ME4000_AI_START_REG                     0x98
 152 #define ME4000_IRQ_STATUS_REG                   0x9c
 153 #define ME4000_IRQ_STATUS_BIT_EX                (1 << 0)
 154 #define ME4000_IRQ_STATUS_BIT_LE                (1 << 1)
 155 #define ME4000_IRQ_STATUS_BIT_AI_HF             (1 << 2)
 156 #define ME4000_IRQ_STATUS_BIT_AO_0_HF           (1 << 3)
 157 #define ME4000_IRQ_STATUS_BIT_AO_1_HF           (1 << 4)
 158 #define ME4000_IRQ_STATUS_BIT_AO_2_HF           (1 << 5)
 159 #define ME4000_IRQ_STATUS_BIT_AO_3_HF           (1 << 6)
 160 #define ME4000_IRQ_STATUS_BIT_SC                (1 << 7)
 161 #define ME4000_DIO_PORT_0_REG                   0xa0
 162 #define ME4000_DIO_PORT_1_REG                   0xa4
 163 #define ME4000_DIO_PORT_2_REG                   0xa8
 164 #define ME4000_DIO_PORT_3_REG                   0xac
 165 #define ME4000_DIO_DIR_REG                      0xb0
 166 #define ME4000_AO_LOADSETREG_XX                 0xb4
 167 #define ME4000_DIO_CTRL_REG                     0xb8
 168 #define ME4000_DIO_CTRL_BIT_MODE_0              (1 << 0)
 169 #define ME4000_DIO_CTRL_BIT_MODE_1              (1 << 1)
 170 #define ME4000_DIO_CTRL_BIT_MODE_2              (1 << 2)
 171 #define ME4000_DIO_CTRL_BIT_MODE_3              (1 << 3)
 172 #define ME4000_DIO_CTRL_BIT_MODE_4              (1 << 4)
 173 #define ME4000_DIO_CTRL_BIT_MODE_5              (1 << 5)
 174 #define ME4000_DIO_CTRL_BIT_MODE_6              (1 << 6)
 175 #define ME4000_DIO_CTRL_BIT_MODE_7              (1 << 7)
 176 #define ME4000_DIO_CTRL_BIT_FUNCTION_0          (1 << 8)
 177 #define ME4000_DIO_CTRL_BIT_FUNCTION_1          (1 << 9)
 178 #define ME4000_DIO_CTRL_BIT_FIFO_HIGH_0         (1 << 10)
 179 #define ME4000_DIO_CTRL_BIT_FIFO_HIGH_1         (1 << 11)
 180 #define ME4000_DIO_CTRL_BIT_FIFO_HIGH_2         (1 << 12)
 181 #define ME4000_DIO_CTRL_BIT_FIFO_HIGH_3         (1 << 13)
 182 #define ME4000_AO_DEMUX_ADJUST_REG              0xbc
 183 #define ME4000_AO_DEMUX_ADJUST_VALUE            0x4c
 184 #define ME4000_AI_SAMPLE_COUNTER_REG            0xc0
 185
 186 /*
 187  * PLX Register map and bit defines
 188  */
 189 #define PLX_INTCSR                              0x4c
 190 #define PLX_INTCSR_LOCAL_INT1_EN                (1 << 0)
 191 #define PLX_INTCSR_LOCAL_INT1_POL               (1 << 1)
 192 #define PLX_INTCSR_LOCAL_INT1_STATE             (1 << 2)
 193 #define PLX_INTCSR_LOCAL_INT2_EN                (1 << 3)
 194 #define PLX_INTCSR_LOCAL_INT2_POL               (1 << 4)
 195 #define PLX_INTCSR_LOCAL_INT2_STATE             (1 << 5)
 196 #define PLX_INTCSR_PCI_INT_EN                   (1 << 6)
 197 #define PLX_INTCSR_SOFT_INT                     (1 << 7)
 198 #define PLX_ICR                                 0x50
 199 #define PLX_ICR_BIT_EEPROM_CLOCK_SET            (1 << 24)
 200 #define PLX_ICR_BIT_EEPROM_CHIP_SELECT          (1 << 25)
 201 #define PLX_ICR_BIT_EEPROM_WRITE                (1 << 26)
 202 #define PLX_ICR_BIT_EEPROM_READ                 (1 << 27)
 203 #define PLX_ICR_BIT_EEPROM_VALID                (1 << 28)
 204 #define PLX_ICR_MASK_EEPROM                     (0x1f << 24)
 205
 206 #define EEPROM_DELAY                            1
 207
 208 #define ME4000_AI_FIFO_COUNT                    2048
 209
 210 #define ME4000_AI_MIN_TICKS                     66
 211 #define ME4000_AI_MIN_SAMPLE_TIME               2000
 212 #define ME4000_AI_BASE_FREQUENCY                (unsigned int) 33E6
 213
 214 #define ME4000_AI_CHANNEL_LIST_COUNT            1024
 215
 216 struct me4000_info {
 217         unsigned long plx_regbase;
 218         unsigned long timer_regbase;
 219
 220         unsigned int ao_readback[4];
 221 };
 222
 223 struct me4000_board {
 224         const char *name;
 225         unsigned short device_id;
 226         int ao_nchan;
 227         int ao_fifo;
 228         int ai_nchan;
 229         int ai_diff_nchan;
 230         int ai_sh_nchan;
 231         int ex_trig_analog;
 232         int dio_nchan;
 233         int has_counter;
 234 };
 235
 236 static const struct me4000_board me4000_boards[] = {
 237         {
 238                 .name           = "ME-4650",
 239                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4650,
 240                 .ai_nchan       = 16,
 241                 .dio_nchan      = 32,
 242         }, {
 243                 .name           = "ME-4660",
 244                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4660,
 245                 .ai_nchan       = 32,
 246                 .ai_diff_nchan  = 16,
 247                 .dio_nchan      = 32,
 248                 .has_counter    = 1,
 249         }, {
 250                 .name           = "ME-4660i",
 251                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4660I,
 252                 .ai_nchan       = 32,
 253                 .ai_diff_nchan  = 16,
 254                 .dio_nchan      = 32,
 255                 .has_counter    = 1,
 256         }, {
 257                 .name           = "ME-4660s",
 258                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4660S,
 259                 .ai_nchan       = 32,
 260                 .ai_diff_nchan  = 16,
 261                 .ai_sh_nchan    = 8,
 262                 .dio_nchan      = 32,
 263                 .has_counter    = 1,
 264         }, {
 265                 .name           = "ME-4660is",
 266                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4660IS,
 267                 .ai_nchan       = 32,
 268                 .ai_diff_nchan  = 16,
 269                 .ai_sh_nchan    = 8,
 270                 .dio_nchan      = 32,
 271                 .has_counter    = 1,
 272         }, {
 273                 .name           = "ME-4670",
 274                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4670,
 275                 .ao_nchan       = 4,
 276                 .ai_nchan       = 32,
 277                 .ai_diff_nchan  = 16,
 278                 .ex_trig_analog = 1,
 279                 .dio_nchan      = 32,
 280                 .has_counter    = 1,
 281         }, {
 282                 .name           = "ME-4670i",
 283                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4670I,
 284                 .ao_nchan       = 4,
 285                 .ai_nchan       = 32,
 286                 .ai_diff_nchan  = 16,
 287                 .ex_trig_analog = 1,
 288                 .dio_nchan      = 32,
 289                 .has_counter    = 1,
 290         }, {
 291                 .name           = "ME-4670s",
 292                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4670S,
 293                 .ao_nchan       = 4,
 294                 .ai_nchan       = 32,
 295                 .ai_diff_nchan  = 16,
 296                 .ai_sh_nchan    = 8,
 297                 .ex_trig_analog = 1,
 298                 .dio_nchan      = 32,
 299                 .has_counter    = 1,
 300         }, {
 301                 .name           = "ME-4670is",
 302                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4670IS,
 303                 .ao_nchan       = 4,
 304                 .ai_nchan       = 32,
 305                 .ai_diff_nchan  = 16,
 306                 .ai_sh_nchan    = 8,
 307                 .ex_trig_analog = 1,
 308                 .dio_nchan      = 32,
 309                 .has_counter    = 1,
 310         }, {
 311                 .name           = "ME-4680",
 312                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4680,
 313                 .ao_nchan       = 4,
 314                 .ao_fifo        = 4,
 315                 .ai_nchan       = 32,
 316                 .ai_diff_nchan  = 16,
 317                 .ex_trig_analog = 1,
 318                 .dio_nchan      = 32,
 319                 .has_counter    = 1,
 320         }, {
 321                 .name           = "ME-4680i",
 322                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4680I,
 323                 .ao_nchan       = 4,
 324                 .ao_fifo        = 4,
 325                 .ai_nchan       = 32,
 326                 .ai_diff_nchan  = 16,
 327                 .ex_trig_analog = 1,
 328                 .dio_nchan      = 32,
 329                 .has_counter    = 1,
 330         }, {
 331                 .name           = "ME-4680s",
 332                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4680S,
 333                 .ao_nchan       = 4,
 334                 .ao_fifo        = 4,
 335                 .ai_nchan       = 32,
 336                 .ai_diff_nchan  = 16,
 337                 .ai_sh_nchan    = 8,
 338                 .ex_trig_analog = 1,
 339                 .dio_nchan      = 32,
 340                 .has_counter    = 1,
 341         }, {
 342                 .name           = "ME-4680is",
 343                 .device_id      = PCI_DEVICE_ID_MEILHAUS_ME4680IS,
 344                 .ao_nchan       = 4,
 345                 .ao_fifo        = 4,
 346                 .ai_nchan       = 32,
 347                 .ai_diff_nchan  = 16,
 348                 .ai_sh_nchan    = 8,
 349                 .ex_trig_analog = 1,
 350                 .dio_nchan      = 32,
 351                 .has_counter    = 1,
 352         },
 353 };
 354
 355 static const struct comedi_lrange me4000_ai_range = {
 356         4,
 357         {
 358          UNI_RANGE(2.5),
 359          UNI_RANGE(10),
 360          BIP_RANGE(2.5),
 361          BIP_RANGE(10),
 362          }
 363 };
 364
 365 #define FIRMWARE_NOT_AVAILABLE 1
 366 #if FIRMWARE_NOT_AVAILABLE
 367 extern unsigned char *xilinx_firm;
 368 #endif
 369
 370 static int xilinx_download(struct comedi_device *dev)
 371 {
 372         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
 373         struct me4000_info *info = dev->private;
 374         unsigned long xilinx_iobase = pci_resource_start(pcidev, 5);
 375         u32 value = 0;
 376         wait_queue_head_t queue;
 377         int idx = 0;
 378         int size = 0;
 379
 380         if (!xilinx_iobase)
 381                 return -ENODEV;
 382
 383         init_waitqueue_head(&queue);
 384
 385         /*
 386          * Set PLX local interrupt 2 polarity to high.
 387          * Interrupt is thrown by init pin of xilinx.
 388          */
 389         outl(0x10, info->plx_regbase + PLX_INTCSR);
 390
 391         /* Set /CS and /WRITE of the Xilinx */
 392         value = inl(info->plx_regbase + PLX_ICR);
 393         value |= 0x100;
 394         outl(value, info->plx_regbase + PLX_ICR);
 395
 396         /* Init Xilinx with CS1 */
 397         inb(xilinx_iobase + 0xC8);
 398
 399         /* Wait until /INIT pin is set */
 400         udelay(20);
 401         if (!(inl(info->plx_regbase + PLX_INTCSR) & 0x20)) {
 402                 dev_err(dev->class_dev, "Can't init Xilinx\n");
 403                 return -EIO;
 404         }
 405
 406         /* Reset /CS and /WRITE of the Xilinx */
 407         value = inl(info->plx_regbase + PLX_ICR);
 408         value &= ~0x100;
 409         outl(value, info->plx_regbase + PLX_ICR);
 410         if (FIRMWARE_NOT_AVAILABLE) {
 411                 dev_err(dev->class_dev,
 412                         "xilinx firmware unavailable due to licensing, aborting");
 413                 return -EIO;
 414         } else {
 415                 /* Download Xilinx firmware */
 416                 size = (xilinx_firm[0] << 24) + (xilinx_firm[1] << 16) +
 417                     (xilinx_firm[2] << 8) + xilinx_firm[3];
 418                 udelay(10);
 419
 420                 for (idx = 0; idx < size; idx++) {
 421                         outb(xilinx_firm[16 + idx], xilinx_iobase);
 422                         udelay(10);
 423
 424                         /* Check if BUSY flag is low */
 425                         if (inl(info->plx_regbase + PLX_ICR) & 0x20) {
 426                                 dev_err(dev->class_dev,
 427                                         "Xilinx is still busy (idx = %d)\n",
 428                                         idx);
 429                                 return -EIO;
 430                         }
 431                 }
 432         }
 433
 434         /* If done flag is high download was successful */
 435         if (inl(info->plx_regbase + PLX_ICR) & 0x4) {
 436         } else {
 437                 dev_err(dev->class_dev, "DONE flag is not set\n");
 438                 dev_err(dev->class_dev, "Download not successful\n");
 439                 return -EIO;
 440         }
 441
 442         /* Set /CS and /WRITE */
 443         value = inl(info->plx_regbase + PLX_ICR);
 444         value |= 0x100;
 445         outl(value, info->plx_regbase + PLX_ICR);
 446
 447         return 0;
 448 }
 449
 450 static void me4000_reset(struct comedi_device *dev)
 451 {
 452         struct me4000_info *info = dev->private;
 453         unsigned long val;
 454         int chan;
 455
 456         /* Make a hardware reset */
 457         val = inl(info->plx_regbase + PLX_ICR);
 458         val |= 0x40000000;
 459         outl(val, info->plx_regbase + PLX_ICR);
 460         val &= ~0x40000000;
 461         outl(val , info->plx_regbase + PLX_ICR);
 462
 463         /* 0x8000 to the DACs means an output voltage of 0V */
 464         for (chan = 0; chan < 4; chan++)
 465                 outl(0x8000, dev->iobase + ME4000_AO_SINGLE_REG(chan));
 466
 467         /* Set both stop bits in the analog input control register */
 468         outl(ME4000_AI_CTRL_BIT_IMMEDIATE_STOP | ME4000_AI_CTRL_BIT_STOP,
 469                 dev->iobase + ME4000_AI_CTRL_REG);
 470
 471         /* Set both stop bits in the analog output control register */
 472         val = ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP;
 473         for (chan = 0; chan < 4; chan++)
 474                 outl(val, dev->iobase + ME4000_AO_CTRL_REG(chan));
 475
 476         /* Enable interrupts on the PLX */
 477         outl(0x43, info->plx_regbase + PLX_INTCSR);
 478
 479         /* Set the adustment register for AO demux */
 480         outl(ME4000_AO_DEMUX_ADJUST_VALUE,
 481                     dev->iobase + ME4000_AO_DEMUX_ADJUST_REG);
 482
 483         /*
 484          * Set digital I/O direction for port 0
 485          * to output on isolated versions
 486          */
 487         if (!(inl(dev->iobase + ME4000_DIO_DIR_REG) & 0x1))
 488                 outl(0x1, dev->iobase + ME4000_DIO_CTRL_REG);
 489 }
 490
 491 /*=============================================================================
 492   Analog input section
 493   ===========================================================================*/
 494
 495 static int me4000_ai_insn_read(struct comedi_device *dev,
 496                                struct comedi_subdevice *subdevice,
 497                                struct comedi_insn *insn, unsigned int *data)
 498 {
 499         const struct me4000_board *thisboard = comedi_board(dev);
 500         int chan = CR_CHAN(insn->chanspec);
 501         int rang = CR_RANGE(insn->chanspec);
 502         int aref = CR_AREF(insn->chanspec);
 503
 504         unsigned long entry = 0;
 505         unsigned long tmp;
 506         long lval;
 507
 508         if (insn->n == 0) {
 509                 return 0;
 510         } else if (insn->n > 1) {
 511                 dev_err(dev->class_dev, "Invalid instruction length %d\n",
 512                         insn->n);
 513                 return -EINVAL;
 514         }
 515
 516         switch (rang) {
 517         case 0:
 518                 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_2_5;
 519                 break;
 520         case 1:
 521                 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_10;
 522                 break;
 523         case 2:
 524                 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_2_5;
 525                 break;
 526         case 3:
 527                 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_10;
 528                 break;
 529         default:
 530                 dev_err(dev->class_dev, "Invalid range specified\n");
 531                 return -EINVAL;
 532         }
 533
 534         switch (aref) {
 535         case AREF_GROUND:
 536         case AREF_COMMON:
 537                 if (chan >= thisboard->ai_nchan) {
 538                         dev_err(dev->class_dev,
 539                                 "Analog input is not available\n");
 540                         return -EINVAL;
 541                 }
 542                 entry |= ME4000_AI_LIST_INPUT_SINGLE_ENDED | chan;
 543                 break;
 544
 545         case AREF_DIFF:
 546                 if (rang == 0 || rang == 1) {
 547                         dev_err(dev->class_dev,
 548                                 "Range must be bipolar when aref = diff\n");
 549                         return -EINVAL;
 550                 }
 551
 552                 if (chan >= thisboard->ai_diff_nchan) {
 553                         dev_err(dev->class_dev,
 554                                 "Analog input is not available\n");
 555                         return -EINVAL;
 556                 }
 557                 entry |= ME4000_AI_LIST_INPUT_DIFFERENTIAL | chan;
 558                 break;
 559         default:
 560                 dev_err(dev->class_dev, "Invalid aref specified\n");
 561                 return -EINVAL;
 562         }
 563
 564         entry |= ME4000_AI_LIST_LAST_ENTRY;
 565
 566         /* Clear channel list, data fifo and both stop bits */
 567         tmp = inl(dev->iobase + ME4000_AI_CTRL_REG);
 568         tmp &= ~(ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
 569                  ME4000_AI_CTRL_BIT_DATA_FIFO |
 570                  ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
 571         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
 572
 573         /* Set the acquisition mode to single */
 574         tmp &= ~(ME4000_AI_CTRL_BIT_MODE_0 | ME4000_AI_CTRL_BIT_MODE_1 |
 575                  ME4000_AI_CTRL_BIT_MODE_2);
 576         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
 577
 578         /* Enable channel list and data fifo */
 579         tmp |= ME4000_AI_CTRL_BIT_CHANNEL_FIFO | ME4000_AI_CTRL_BIT_DATA_FIFO;
 580         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
 581
 582         /* Generate channel list entry */
 583         outl(entry, dev->iobase + ME4000_AI_CHANNEL_LIST_REG);
 584
 585         /* Set the timer to maximum sample rate */
 586         outl(ME4000_AI_MIN_TICKS, dev->iobase + ME4000_AI_CHAN_TIMER_REG);
 587         outl(ME4000_AI_MIN_TICKS, dev->iobase + ME4000_AI_CHAN_PRE_TIMER_REG);
 588
 589         /* Start conversion by dummy read */
 590         inl(dev->iobase + ME4000_AI_START_REG);
 591
 592         /* Wait until ready */
 593         udelay(10);
 594         if (!(inl(dev->iobase + ME4000_AI_STATUS_REG) &
 595              ME4000_AI_STATUS_BIT_EF_DATA)) {
 596                 dev_err(dev->class_dev, "Value not available after wait\n");
 597                 return -EIO;
 598         }
 599
 600         /* Read value from data fifo */
 601         lval = inl(dev->iobase + ME4000_AI_DATA_REG) & 0xFFFF;
 602         data[0] = lval ^ 0x8000;
 603
 604         return 1;
 605 }
 606
 607 static int me4000_ai_cancel(struct comedi_device *dev,
 608                             struct comedi_subdevice *s)
 609 {
 610         unsigned long tmp;
 611
 612         /* Stop any running conversion */
 613         tmp = inl(dev->iobase + ME4000_AI_CTRL_REG);
 614         tmp &= ~(ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
 615         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
 616
 617         /* Clear the control register */
 618         outl(0x0, dev->iobase + ME4000_AI_CTRL_REG);
 619
 620         return 0;
 621 }
 622
 623 static int ai_check_chanlist(struct comedi_device *dev,
 624                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
 625 {
 626         const struct me4000_board *thisboard = comedi_board(dev);
 627         int aref;
 628         int i;
 629
 630         /* Check whether a channel list is available */
 631         if (!cmd->chanlist_len) {
 632                 dev_err(dev->class_dev, "No channel list available\n");
 633                 return -EINVAL;
 634         }
 635
 636         /* Check the channel list size */
 637         if (cmd->chanlist_len > ME4000_AI_CHANNEL_LIST_COUNT) {
 638                 dev_err(dev->class_dev, "Channel list is to large\n");
 639                 return -EINVAL;
 640         }
 641
 642         /* Check the pointer */
 643         if (!cmd->chanlist) {
 644                 dev_err(dev->class_dev, "NULL pointer to channel list\n");
 645                 return -EFAULT;
 646         }
 647
 648         /* Check whether aref is equal for all entries */
 649         aref = CR_AREF(cmd->chanlist[0]);
 650         for (i = 0; i < cmd->chanlist_len; i++) {
 651                 if (CR_AREF(cmd->chanlist[i]) != aref) {
 652                         dev_err(dev->class_dev,
 653                                 "Mode is not equal for all entries\n");
 654                         return -EINVAL;
 655                 }
 656         }
 657
 658         /* Check whether channels are available for this ending */
 659         if (aref == SDF_DIFF) {
 660                 for (i = 0; i < cmd->chanlist_len; i++) {
 661                         if (CR_CHAN(cmd->chanlist[i]) >=
 662                             thisboard->ai_diff_nchan) {
 663                                 dev_err(dev->class_dev,
 664                                         "Channel number to high\n");
 665                                 return -EINVAL;
 666                         }
 667                 }
 668         } else {
 669                 for (i = 0; i < cmd->chanlist_len; i++) {
 670                         if (CR_CHAN(cmd->chanlist[i]) >= thisboard->ai_nchan) {
 671                                 dev_err(dev->class_dev,
 672                                         "Channel number to high\n");
 673                                 return -EINVAL;
 674                         }
 675                 }
 676         }
 677
 678         /* Check if bipolar is set for all entries when in differential mode */
 679         if (aref == SDF_DIFF) {
 680                 for (i = 0; i < cmd->chanlist_len; i++) {
 681                         if (CR_RANGE(cmd->chanlist[i]) != 1 &&
 682                             CR_RANGE(cmd->chanlist[i]) != 2) {
 683                                 dev_err(dev->class_dev,
 684                                        "Bipolar is not selected in differential mode\n");
 685                                 return -EINVAL;
 686                         }
 687                 }
 688         }
 689
 690         return 0;
 691 }
 692
 693 static int ai_round_cmd_args(struct comedi_device *dev,
 694                              struct comedi_subdevice *s,
 695                              struct comedi_cmd *cmd,
 696                              unsigned int *init_ticks,
 697                              unsigned int *scan_ticks, unsigned int *chan_ticks)
 698 {
 699
 700         int rest;
 701
 702         *init_ticks = 0;
 703         *scan_ticks = 0;
 704         *chan_ticks = 0;
 705
 706         if (cmd->start_arg) {
 707                 *init_ticks = (cmd->start_arg * 33) / 1000;
 708                 rest = (cmd->start_arg * 33) % 1000;
 709
 710                 if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_NEAREST) {
 711                         if (rest > 33)
 712                                 (*init_ticks)++;
 713                 } else if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_UP) {
 714                         if (rest)
 715                                 (*init_ticks)++;
 716                 }
 717         }
 718
 719         if (cmd->scan_begin_arg) {
 720                 *scan_ticks = (cmd->scan_begin_arg * 33) / 1000;
 721                 rest = (cmd->scan_begin_arg * 33) % 1000;
 722
 723                 if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_NEAREST) {
 724                         if (rest > 33)
 725                                 (*scan_ticks)++;
 726                 } else if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_UP) {
 727                         if (rest)
 728                                 (*scan_ticks)++;
 729                 }
 730         }
 731
 732         if (cmd->convert_arg) {
 733                 *chan_ticks = (cmd->convert_arg * 33) / 1000;
 734                 rest = (cmd->convert_arg * 33) % 1000;
 735
 736                 if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_NEAREST) {
 737                         if (rest > 33)
 738                                 (*chan_ticks)++;
 739                 } else if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_UP) {
 740                         if (rest)
 741                                 (*chan_ticks)++;
 742                 }
 743         }
 744
 745         return 0;
 746 }
 747
 748 static void ai_write_timer(struct comedi_device *dev,
 749                            unsigned int init_ticks,
 750                            unsigned int scan_ticks, unsigned int chan_ticks)
 751 {
 752         outl(init_ticks - 1, dev->iobase + ME4000_AI_SCAN_PRE_TIMER_LOW_REG);
 753         outl(0x0, dev->iobase + ME4000_AI_SCAN_PRE_TIMER_HIGH_REG);
 754
 755         if (scan_ticks) {
 756                 outl(scan_ticks - 1, dev->iobase + ME4000_AI_SCAN_TIMER_LOW_REG);
 757                 outl(0x0, dev->iobase + ME4000_AI_SCAN_TIMER_HIGH_REG);
 758         }
 759
 760         outl(chan_ticks - 1, dev->iobase + ME4000_AI_CHAN_PRE_TIMER_REG);
 761         outl(chan_ticks - 1, dev->iobase + ME4000_AI_CHAN_TIMER_REG);
 762 }
 763
 764 static int ai_write_chanlist(struct comedi_device *dev,
 765                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
 766 {
 767         unsigned int entry;
 768         unsigned int chan;
 769         unsigned int rang;
 770         unsigned int aref;
 771         int i;
 772
 773         for (i = 0; i < cmd->chanlist_len; i++) {
 774                 chan = CR_CHAN(cmd->chanlist[i]);
 775                 rang = CR_RANGE(cmd->chanlist[i]);
 776                 aref = CR_AREF(cmd->chanlist[i]);
 777
 778                 entry = chan;
 779
 780                 if (rang == 0)
 781                         entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_2_5;
 782                 else if (rang == 1)
 783                         entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_10;
 784                 else if (rang == 2)
 785                         entry |= ME4000_AI_LIST_RANGE_BIPOLAR_2_5;
 786                 else
 787                         entry |= ME4000_AI_LIST_RANGE_BIPOLAR_10;
 788
 789                 if (aref == SDF_DIFF)
 790                         entry |= ME4000_AI_LIST_INPUT_DIFFERENTIAL;
 791                 else
 792                         entry |= ME4000_AI_LIST_INPUT_SINGLE_ENDED;
 793
 794                 outl(entry, dev->iobase + ME4000_AI_CHANNEL_LIST_REG);
 795         }
 796
 797         return 0;
 798 }
 799
 800 static int ai_prepare(struct comedi_device *dev,
 801                       struct comedi_subdevice *s,
 802                       struct comedi_cmd *cmd,
 803                       unsigned int init_ticks,
 804                       unsigned int scan_ticks, unsigned int chan_ticks)
 805 {
 806
 807         unsigned long tmp = 0;
 808
 809         /* Write timer arguments */
 810         ai_write_timer(dev, init_ticks, scan_ticks, chan_ticks);
 811
 812         /* Reset control register */
 813         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
 814
 815         /* Start sources */
 816         if ((cmd->start_src == TRIG_EXT &&
 817              cmd->scan_begin_src == TRIG_TIMER &&
 818              cmd->convert_src == TRIG_TIMER) ||
 819             (cmd->start_src == TRIG_EXT &&
 820              cmd->scan_begin_src == TRIG_FOLLOW &&
 821              cmd->convert_src == TRIG_TIMER)) {
 822                 tmp = ME4000_AI_CTRL_BIT_MODE_1 |
 823                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
 824                     ME4000_AI_CTRL_BIT_DATA_FIFO;
 825         } else if (cmd->start_src == TRIG_EXT &&
 826                    cmd->scan_begin_src == TRIG_EXT &&
 827                    cmd->convert_src == TRIG_TIMER) {
 828                 tmp = ME4000_AI_CTRL_BIT_MODE_2 |
 829                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
 830                     ME4000_AI_CTRL_BIT_DATA_FIFO;
 831         } else if (cmd->start_src == TRIG_EXT &&
 832                    cmd->scan_begin_src == TRIG_EXT &&
 833                    cmd->convert_src == TRIG_EXT) {
 834                 tmp = ME4000_AI_CTRL_BIT_MODE_0 |
 835                     ME4000_AI_CTRL_BIT_MODE_1 |
 836                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
 837                     ME4000_AI_CTRL_BIT_DATA_FIFO;
 838         } else {
 839                 tmp = ME4000_AI_CTRL_BIT_MODE_0 |
 840                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
 841                     ME4000_AI_CTRL_BIT_DATA_FIFO;
 842         }
 843
 844         /* Stop triggers */
 845         if (cmd->stop_src == TRIG_COUNT) {
 846                 outl(cmd->chanlist_len * cmd->stop_arg,
 847                             dev->iobase + ME4000_AI_SAMPLE_COUNTER_REG);
 848                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
 849         } else if (cmd->stop_src == TRIG_NONE &&
 850                    cmd->scan_end_src == TRIG_COUNT) {
 851                 outl(cmd->scan_end_arg,
 852                             dev->iobase + ME4000_AI_SAMPLE_COUNTER_REG);
 853                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
 854         } else {
 855                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ;
 856         }
 857
 858         /* Write the setup to the control register */
 859         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
 860
 861         /* Write the channel list */
 862         ai_write_chanlist(dev, s, cmd);
 863
 864         return 0;
 865 }
 866
 867 static int me4000_ai_do_cmd(struct comedi_device *dev,
 868                             struct comedi_subdevice *s)
 869 {
 870         int err;
 871         unsigned int init_ticks = 0;
 872         unsigned int scan_ticks = 0;
 873         unsigned int chan_ticks = 0;
 874         struct comedi_cmd *cmd = &s->async->cmd;
 875
 876         /* Reset the analog input */
 877         err = me4000_ai_cancel(dev, s);
 878         if (err)
 879                 return err;
 880
 881         /* Round the timer arguments */
 882         err = ai_round_cmd_args(dev,
 883                                 s, cmd, &init_ticks, &scan_ticks, &chan_ticks);
 884         if (err)
 885                 return err;
 886
 887         /* Prepare the AI for acquisition */
 888         err = ai_prepare(dev, s, cmd, init_ticks, scan_ticks, chan_ticks);
 889         if (err)
 890                 return err;
 891
 892         /* Start acquistion by dummy read */
 893         inl(dev->iobase + ME4000_AI_START_REG);
 894
 895         return 0;
 896 }
 897
 898 static int me4000_ai_do_cmd_test(struct comedi_device *dev,
 899                                  struct comedi_subdevice *s,
 900                                  struct comedi_cmd *cmd)
 901 {
 902
 903         unsigned int init_ticks;
 904         unsigned int chan_ticks;
 905         unsigned int scan_ticks;
 906         int err = 0;
 907
 908         /* Only rounding flags are implemented */
 909         cmd->flags &= TRIG_ROUND_NEAREST | TRIG_ROUND_UP | TRIG_ROUND_DOWN;
 910
 911         /* Round the timer arguments */
 912         ai_round_cmd_args(dev, s, cmd, &init_ticks, &scan_ticks, &chan_ticks);
 913
 914         /* Step 1 : check if triggers are trivially valid */
 915
 916         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
 917         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
 918                                         TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
 919         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
 920         err |= cfc_check_trigger_src(&cmd->scan_end_src,
 921                                         TRIG_NONE | TRIG_COUNT);
 922         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE | TRIG_COUNT);
 923
 924         if (err)
 925                 return 1;
 926
 927         /* Step 2a : make sure trigger sources are unique */
 928
 929         err |= cfc_check_trigger_is_unique(cmd->start_src);
 930         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
 931         err |= cfc_check_trigger_is_unique(cmd->convert_src);
 932         err |= cfc_check_trigger_is_unique(cmd->scan_end_src);
 933         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 934
 935         /* Step 2b : and mutually compatible */
 936
 937         if (cmd->start_src == TRIG_NOW &&
 938             cmd->scan_begin_src == TRIG_TIMER &&
 939             cmd->convert_src == TRIG_TIMER) {
 940         } else if (cmd->start_src == TRIG_NOW &&
 941                    cmd->scan_begin_src == TRIG_FOLLOW &&
 942                    cmd->convert_src == TRIG_TIMER) {
 943         } else if (cmd->start_src == TRIG_EXT &&
 944                    cmd->scan_begin_src == TRIG_TIMER &&
 945                    cmd->convert_src == TRIG_TIMER) {
 946         } else if (cmd->start_src == TRIG_EXT &&
 947                    cmd->scan_begin_src == TRIG_FOLLOW &&
 948                    cmd->convert_src == TRIG_TIMER) {
 949         } else if (cmd->start_src == TRIG_EXT &&
 950                    cmd->scan_begin_src == TRIG_EXT &&
 951                    cmd->convert_src == TRIG_TIMER) {
 952         } else if (cmd->start_src == TRIG_EXT &&
 953                    cmd->scan_begin_src == TRIG_EXT &&
 954                    cmd->convert_src == TRIG_EXT) {
 955         } else {
 956                 err |= -EINVAL;
 957         }
 958
 959         if (cmd->stop_src == TRIG_NONE && cmd->scan_end_src == TRIG_NONE) {
 960         } else if (cmd->stop_src == TRIG_COUNT &&
 961                    cmd->scan_end_src == TRIG_NONE) {
 962         } else if (cmd->stop_src == TRIG_NONE &&
 963                    cmd->scan_end_src == TRIG_COUNT) {
 964         } else if (cmd->stop_src == TRIG_COUNT &&
 965                    cmd->scan_end_src == TRIG_COUNT) {
 966         } else {
 967                 err |= -EINVAL;
 968         }
 969
 970         if (err)
 971                 return 2;
 972
 973         /* Step 3: check if arguments are trivially valid */
 974
 975         if (cmd->chanlist_len < 1) {
 976                 cmd->chanlist_len = 1;
 977                 err |= -EINVAL;
 978         }
 979         if (init_ticks < 66) {
 980                 cmd->start_arg = 2000;
 981                 err |= -EINVAL;
 982         }
 983         if (scan_ticks && scan_ticks < 67) {
 984                 cmd->scan_begin_arg = 2031;
 985                 err |= -EINVAL;
 986         }
 987         if (chan_ticks < 66) {
 988                 cmd->convert_arg = 2000;
 989                 err |= -EINVAL;
 990         }
 991
 992         if (err)
 993                 return 3;
 994
 995         /*
 996          * Stage 4. Check for argument conflicts.
 997          */
 998         if (cmd->start_src == TRIG_NOW &&
 999             cmd->scan_begin_src == TRIG_TIMER &&
1000             cmd->convert_src == TRIG_TIMER) {
1001
1002                 /* Check timer arguments */
1003                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1004                         dev_err(dev->class_dev, "Invalid start arg\n");
1005                         cmd->start_arg = 2000;  /*  66 ticks at least */
1006                         err++;
1007                 }
1008                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1009                         dev_err(dev->class_dev, "Invalid convert arg\n");
1010                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1011                         err++;
1012                 }
1013                 if (scan_ticks <= cmd->chanlist_len * chan_ticks) {
1014                         dev_err(dev->class_dev, "Invalid scan end arg\n");
1015
1016                         /*  At least one tick more */
1017                         cmd->scan_end_arg = 2000 * cmd->chanlist_len + 31;
1018                         err++;
1019                 }
1020         } else if (cmd->start_src == TRIG_NOW &&
1021                    cmd->scan_begin_src == TRIG_FOLLOW &&
1022                    cmd->convert_src == TRIG_TIMER) {
1023
1024                 /* Check timer arguments */
1025                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1026                         dev_err(dev->class_dev, "Invalid start arg\n");
1027                         cmd->start_arg = 2000;  /*  66 ticks at least */
1028                         err++;
1029                 }
1030                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1031                         dev_err(dev->class_dev, "Invalid convert arg\n");
1032                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1033                         err++;
1034                 }
1035         } else if (cmd->start_src == TRIG_EXT &&
1036                    cmd->scan_begin_src == TRIG_TIMER &&
1037                    cmd->convert_src == TRIG_TIMER) {
1038
1039                 /* Check timer arguments */
1040                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1041                         dev_err(dev->class_dev, "Invalid start arg\n");
1042                         cmd->start_arg = 2000;  /*  66 ticks at least */
1043                         err++;
1044                 }
1045                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1046                         dev_err(dev->class_dev, "Invalid convert arg\n");
1047                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1048                         err++;
1049                 }
1050                 if (scan_ticks <= cmd->chanlist_len * chan_ticks) {
1051                         dev_err(dev->class_dev, "Invalid scan end arg\n");
1052
1053                         /*  At least one tick more */
1054                         cmd->scan_end_arg = 2000 * cmd->chanlist_len + 31;
1055                         err++;
1056                 }
1057         } else if (cmd->start_src == TRIG_EXT &&
1058                    cmd->scan_begin_src == TRIG_FOLLOW &&
1059                    cmd->convert_src == TRIG_TIMER) {
1060
1061                 /* Check timer arguments */
1062                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1063                         dev_err(dev->class_dev, "Invalid start arg\n");
1064                         cmd->start_arg = 2000;  /*  66 ticks at least */
1065                         err++;
1066                 }
1067                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1068                         dev_err(dev->class_dev, "Invalid convert arg\n");
1069                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1070                         err++;
1071                 }
1072         } else if (cmd->start_src == TRIG_EXT &&
1073                    cmd->scan_begin_src == TRIG_EXT &&
1074                    cmd->convert_src == TRIG_TIMER) {
1075
1076                 /* Check timer arguments */
1077                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1078                         dev_err(dev->class_dev, "Invalid start arg\n");
1079                         cmd->start_arg = 2000;  /*  66 ticks at least */
1080                         err++;
1081                 }
1082                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1083                         dev_err(dev->class_dev, "Invalid convert arg\n");
1084                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1085                         err++;
1086                 }
1087         } else if (cmd->start_src == TRIG_EXT &&
1088                    cmd->scan_begin_src == TRIG_EXT &&
1089                    cmd->convert_src == TRIG_EXT) {
1090
1091                 /* Check timer arguments */
1092                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1093                         dev_err(dev->class_dev, "Invalid start arg\n");
1094                         cmd->start_arg = 2000;  /*  66 ticks at least */
1095                         err++;
1096                 }
1097         }
1098         if (cmd->stop_src == TRIG_COUNT) {
1099                 if (cmd->stop_arg == 0) {
1100                         dev_err(dev->class_dev, "Invalid stop arg\n");
1101                         cmd->stop_arg = 1;
1102                         err++;
1103                 }
1104         }
1105         if (cmd->scan_end_src == TRIG_COUNT) {
1106                 if (cmd->scan_end_arg == 0) {
1107                         dev_err(dev->class_dev, "Invalid scan end arg\n");
1108                         cmd->scan_end_arg = 1;
1109                         err++;
1110                 }
1111         }
1112
1113         if (err)
1114                 return 4;
1115
1116         /*
1117          * Stage 5. Check the channel list.
1118          */
1119         if (ai_check_chanlist(dev, s, cmd))
1120                 return 5;
1121
1122         return 0;
1123 }
1124
1125 static irqreturn_t me4000_ai_isr(int irq, void *dev_id)
1126 {
1127         unsigned int tmp;
1128         struct comedi_device *dev = dev_id;
1129         struct comedi_subdevice *s = &dev->subdevices[0];
1130         int i;
1131         int c = 0;
1132         long lval;
1133
1134         if (!dev->attached)
1135                 return IRQ_NONE;
1136
1137         /* Reset all events */
1138         s->async->events = 0;
1139
1140         /* Check if irq number is right */
1141         if (irq != dev->irq) {
1142                 dev_err(dev->class_dev, "Incorrect interrupt num: %d\n", irq);
1143                 return IRQ_HANDLED;
1144         }
1145
1146         if (inl(dev->iobase + ME4000_IRQ_STATUS_REG) &
1147             ME4000_IRQ_STATUS_BIT_AI_HF) {
1148                 /* Read status register to find out what happened */
1149                 tmp = inl(dev->iobase + ME4000_AI_CTRL_REG);
1150
1151                 if (!(tmp & ME4000_AI_STATUS_BIT_FF_DATA) &&
1152                     !(tmp & ME4000_AI_STATUS_BIT_HF_DATA) &&
1153                     (tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
1154                         c = ME4000_AI_FIFO_COUNT;
1155
1156                         /*
1157                          * FIFO overflow, so stop conversion
1158                          * and disable all interrupts
1159                          */
1160                         tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1161                         tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1162                                  ME4000_AI_CTRL_BIT_SC_IRQ);
1163                         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1164
1165                         s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
1166
1167                         dev_err(dev->class_dev, "FIFO overflow\n");
1168                 } else if ((tmp & ME4000_AI_STATUS_BIT_FF_DATA)
1169                            && !(tmp & ME4000_AI_STATUS_BIT_HF_DATA)
1170                            && (tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
1171                         s->async->events |= COMEDI_CB_BLOCK;
1172
1173                         c = ME4000_AI_FIFO_COUNT / 2;
1174                 } else {
1175                         dev_err(dev->class_dev,
1176                                 "Can't determine state of fifo\n");
1177                         c = 0;
1178
1179                         /*
1180                          * Undefined state, so stop conversion
1181                          * and disable all interrupts
1182                          */
1183                         tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1184                         tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1185                                  ME4000_AI_CTRL_BIT_SC_IRQ);
1186                         outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1187
1188                         s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
1189
1190                         dev_err(dev->class_dev, "Undefined FIFO state\n");
1191                 }
1192
1193                 for (i = 0; i < c; i++) {
1194                         /* Read value from data fifo */
1195                         lval = inl(dev->iobase + ME4000_AI_DATA_REG) & 0xFFFF;
1196                         lval ^= 0x8000;
1197
1198                         if (!comedi_buf_put(s->async, lval)) {
1199                                 /*
1200                                  * Buffer overflow, so stop conversion
1201                                  * and disable all interrupts
1202                                  */
1203                                 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1204                                 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1205                                          ME4000_AI_CTRL_BIT_SC_IRQ);
1206                                 outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1207
1208                                 s->async->events |= COMEDI_CB_OVERFLOW;
1209
1210                                 dev_err(dev->class_dev, "Buffer overflow\n");
1211
1212                                 break;
1213                         }
1214                 }
1215
1216                 /* Work is done, so reset the interrupt */
1217                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
1218                 outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1219                 tmp &= ~ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
1220                 outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1221         }
1222
1223         if (inl(dev->iobase + ME4000_IRQ_STATUS_REG) &
1224             ME4000_IRQ_STATUS_BIT_SC) {
1225                 s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOA;
1226
1227                 /*
1228                  * Acquisition is complete, so stop
1229                  * conversion and disable all interrupts
1230                  */
1231                 tmp = inl(dev->iobase + ME4000_AI_CTRL_REG);
1232                 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1233                 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ);
1234                 outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1235
1236                 /* Poll data until fifo empty */
1237                 while (inl(dev->iobase + ME4000_AI_CTRL_REG) &
1238                        ME4000_AI_STATUS_BIT_EF_DATA) {
1239                         /* Read value from data fifo */
1240                         lval = inl(dev->iobase + ME4000_AI_DATA_REG) & 0xFFFF;
1241                         lval ^= 0x8000;
1242
1243                         if (!comedi_buf_put(s->async, lval)) {
1244                                 dev_err(dev->class_dev, "Buffer overflow\n");
1245                                 s->async->events |= COMEDI_CB_OVERFLOW;
1246                                 break;
1247                         }
1248                 }
1249
1250                 /* Work is done, so reset the interrupt */
1251                 tmp |= ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
1252                 outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1253                 tmp &= ~ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
1254                 outl(tmp, dev->iobase + ME4000_AI_CTRL_REG);
1255         }
1256
1257         if (s->async->events)
1258                 comedi_event(dev, s);
1259
1260         return IRQ_HANDLED;
1261 }
1262
1263 /*=============================================================================
1264   Analog output section
1265   ===========================================================================*/
1266
1267 static int me4000_ao_insn_write(struct comedi_device *dev,
1268                                 struct comedi_subdevice *s,
1269                                 struct comedi_insn *insn, unsigned int *data)
1270 {
1271         const struct me4000_board *thisboard = comedi_board(dev);
1272         struct me4000_info *info = dev->private;
1273         int chan = CR_CHAN(insn->chanspec);
1274         int rang = CR_RANGE(insn->chanspec);
1275         int aref = CR_AREF(insn->chanspec);
1276         unsigned long tmp;
1277
1278         if (insn->n == 0) {
1279                 return 0;
1280         } else if (insn->n > 1) {
1281                 dev_err(dev->class_dev, "Invalid instruction length %d\n",
1282                         insn->n);
1283                 return -EINVAL;
1284         }
1285
1286         if (chan >= thisboard->ao_nchan) {
1287                 dev_err(dev->class_dev, "Invalid channel %d\n", insn->n);
1288                 return -EINVAL;
1289         }
1290
1291         if (rang != 0) {
1292                 dev_err(dev->class_dev, "Invalid range %d\n", insn->n);
1293                 return -EINVAL;
1294         }
1295
1296         if (aref != AREF_GROUND && aref != AREF_COMMON) {
1297                 dev_err(dev->class_dev, "Invalid aref %d\n", insn->n);
1298                 return -EINVAL;
1299         }
1300
1301         /* Stop any running conversion */
1302         tmp = inl(dev->iobase + ME4000_AO_CTRL_REG(chan));
1303         tmp |= ME4000_AO_CTRL_BIT_IMMEDIATE_STOP;
1304         outl(tmp, dev->iobase + ME4000_AO_CTRL_REG(chan));
1305
1306         /* Clear control register and set to single mode */
1307         outl(0x0, dev->iobase + ME4000_AO_CTRL_REG(chan));
1308
1309         /* Write data value */
1310         outl(data[0], dev->iobase + ME4000_AO_SINGLE_REG(chan));
1311
1312         /* Store in the mirror */
1313         info->ao_readback[chan] = data[0];
1314
1315         return 1;
1316 }
1317
1318 static int me4000_ao_insn_read(struct comedi_device *dev,
1319                                struct comedi_subdevice *s,
1320                                struct comedi_insn *insn, unsigned int *data)
1321 {
1322         struct me4000_info *info = dev->private;
1323         int chan = CR_CHAN(insn->chanspec);
1324
1325         if (insn->n == 0) {
1326                 return 0;
1327         } else if (insn->n > 1) {
1328                 dev_err(dev->class_dev, "Invalid instruction length\n");
1329                 return -EINVAL;
1330         }
1331
1332         data[0] = info->ao_readback[chan];
1333
1334         return 1;
1335 }
1336
1337 /*=============================================================================
1338   Digital I/O section
1339   ===========================================================================*/
1340
1341 static int me4000_dio_insn_bits(struct comedi_device *dev,
1342                                 struct comedi_subdevice *s,
1343                                 struct comedi_insn *insn, unsigned int *data)
1344 {
1345         /*
1346          * The insn data consists of a mask in data[0] and the new data
1347          * in data[1]. The mask defines which bits we are concerning about.
1348          * The new data must be anded with the mask.
1349          * Each channel corresponds to a bit.
1350          */
1351         if (data[0]) {
1352                 /* Check if requested ports are configured for output */
1353                 if ((s->io_bits & data[0]) != data[0])
1354                         return -EIO;
1355
1356                 s->state &= ~data[0];
1357                 s->state |= data[0] & data[1];
1358
1359                 /* Write out the new digital output lines */
1360                 outl((s->state >> 0) & 0xFF,
1361                             dev->iobase + ME4000_DIO_PORT_0_REG);
1362                 outl((s->state >> 8) & 0xFF,
1363                             dev->iobase + ME4000_DIO_PORT_1_REG);
1364                 outl((s->state >> 16) & 0xFF,
1365                             dev->iobase + ME4000_DIO_PORT_2_REG);
1366                 outl((s->state >> 24) & 0xFF,
1367                             dev->iobase + ME4000_DIO_PORT_3_REG);
1368         }
1369
1370         /* On return, data[1] contains the value of
1371            the digital input and output lines. */
1372         data[1] = ((inl(dev->iobase + ME4000_DIO_PORT_0_REG) & 0xFF) << 0) |
1373                   ((inl(dev->iobase + ME4000_DIO_PORT_1_REG) & 0xFF) << 8) |
1374                   ((inl(dev->iobase + ME4000_DIO_PORT_2_REG) & 0xFF) << 16) |
1375                   ((inl(dev->iobase + ME4000_DIO_PORT_3_REG) & 0xFF) << 24);
1376
1377         return insn->n;
1378 }
1379
1380 static int me4000_dio_insn_config(struct comedi_device *dev,
1381                                   struct comedi_subdevice *s,
1382                                   struct comedi_insn *insn, unsigned int *data)
1383 {
1384         unsigned long tmp;
1385         int chan = CR_CHAN(insn->chanspec);
1386
1387         switch (data[0]) {
1388         default:
1389                 return -EINVAL;
1390         case INSN_CONFIG_DIO_QUERY:
1391                 data[1] =
1392                     (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
1393                 return insn->n;
1394         case INSN_CONFIG_DIO_INPUT:
1395         case INSN_CONFIG_DIO_OUTPUT:
1396                 break;
1397         }
1398
1399         /*
1400          * The input or output configuration of each digital line is
1401          * configured by a special insn_config instruction.  chanspec
1402          * contains the channel to be changed, and data[0] contains the
1403          * value INSN_CONFIG_DIO_INPUT or INSN_CONFIG_DIO_OUTPUT.
1404          * On the ME-4000 it is only possible to switch port wise (8 bit)
1405          */
1406
1407         tmp = inl(dev->iobase + ME4000_DIO_CTRL_REG);
1408
1409         if (data[0] == INSN_CONFIG_DIO_OUTPUT) {
1410                 if (chan < 8) {
1411                         s->io_bits |= 0xFF;
1412                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_0 |
1413                                  ME4000_DIO_CTRL_BIT_MODE_1);
1414                         tmp |= ME4000_DIO_CTRL_BIT_MODE_0;
1415                 } else if (chan < 16) {
1416                         /*
1417                          * Chech for optoisolated ME-4000 version.
1418                          * If one the first port is a fixed output
1419                          * port and the second is a fixed input port.
1420                          */
1421                         if (!inl(dev->iobase + ME4000_DIO_DIR_REG))
1422                                 return -ENODEV;
1423
1424                         s->io_bits |= 0xFF00;
1425                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_2 |
1426                                  ME4000_DIO_CTRL_BIT_MODE_3);
1427                         tmp |= ME4000_DIO_CTRL_BIT_MODE_2;
1428                 } else if (chan < 24) {
1429                         s->io_bits |= 0xFF0000;
1430                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_4 |
1431                                  ME4000_DIO_CTRL_BIT_MODE_5);
1432                         tmp |= ME4000_DIO_CTRL_BIT_MODE_4;
1433                 } else if (chan < 32) {
1434                         s->io_bits |= 0xFF000000;
1435                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_6 |
1436                                  ME4000_DIO_CTRL_BIT_MODE_7);
1437                         tmp |= ME4000_DIO_CTRL_BIT_MODE_6;
1438                 } else {
1439                         return -EINVAL;
1440                 }
1441         } else {
1442                 if (chan < 8) {
1443                         /*
1444                          * Chech for optoisolated ME-4000 version.
1445                          * If one the first port is a fixed output
1446                          * port and the second is a fixed input port.
1447                          */
1448                         if (!inl(dev->iobase + ME4000_DIO_DIR_REG))
1449                                 return -ENODEV;
1450
1451                         s->io_bits &= ~0xFF;
1452                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_0 |
1453                                  ME4000_DIO_CTRL_BIT_MODE_1);
1454                 } else if (chan < 16) {
1455                         s->io_bits &= ~0xFF00;
1456                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_2 |
1457                                  ME4000_DIO_CTRL_BIT_MODE_3);
1458                 } else if (chan < 24) {
1459                         s->io_bits &= ~0xFF0000;
1460                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_4 |
1461                                  ME4000_DIO_CTRL_BIT_MODE_5);
1462                 } else if (chan < 32) {
1463                         s->io_bits &= ~0xFF000000;
1464                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_6 |
1465                                  ME4000_DIO_CTRL_BIT_MODE_7);
1466                 } else {
1467                         return -EINVAL;
1468                 }
1469         }
1470
1471         outl(tmp, dev->iobase + ME4000_DIO_CTRL_REG);
1472
1473         return 1;
1474 }
1475
1476 /*=============================================================================
1477   Counter section
1478   ===========================================================================*/
1479
1480 static int me4000_cnt_insn_config(struct comedi_device *dev,
1481                                   struct comedi_subdevice *s,
1482                                   struct comedi_insn *insn,
1483                                   unsigned int *data)
1484 {
1485         struct me4000_info *info = dev->private;
1486         int err;
1487
1488         switch (data[0]) {
1489         case GPCT_RESET:
1490                 if (insn->n != 1)
1491                         return -EINVAL;
1492
1493                 err = i8254_load(info->timer_regbase, 0, insn->chanspec, 0,
1494                                 I8254_MODE0 | I8254_BINARY);
1495                 if (err)
1496                         return err;
1497                 break;
1498         case GPCT_SET_OPERATION:
1499                 if (insn->n != 2)
1500                         return -EINVAL;
1501
1502                 err = i8254_set_mode(info->timer_regbase, 0, insn->chanspec,
1503                                 (data[1] << 1) | I8254_BINARY);
1504                 if (err)
1505                         return err;
1506                 break;
1507         default:
1508                 return -EINVAL;
1509         }
1510
1511         return insn->n;
1512 }
1513
1514 static int me4000_cnt_insn_read(struct comedi_device *dev,
1515                                 struct comedi_subdevice *s,
1516                                 struct comedi_insn *insn, unsigned int *data)
1517 {
1518         struct me4000_info *info = dev->private;
1519
1520         if (insn->n == 0)
1521                 return 0;
1522
1523         if (insn->n > 1) {
1524                 dev_err(dev->class_dev, "Invalid instruction length %d\n",
1525                         insn->n);
1526                 return -EINVAL;
1527         }
1528
1529         data[0] = i8254_read(info->timer_regbase, 0, insn->chanspec);
1530
1531         return 1;
1532 }
1533
1534 static int me4000_cnt_insn_write(struct comedi_device *dev,
1535                                  struct comedi_subdevice *s,
1536                                  struct comedi_insn *insn, unsigned int *data)
1537 {
1538         struct me4000_info *info = dev->private;
1539
1540         if (insn->n == 0) {
1541                 return 0;
1542         } else if (insn->n > 1) {
1543                 dev_err(dev->class_dev, "Invalid instruction length %d\n",
1544                         insn->n);
1545                 return -EINVAL;
1546         }
1547
1548         i8254_write(info->timer_regbase, 0, insn->chanspec, data[0]);
1549
1550         return 1;
1551 }
1552
1553 static const void *me4000_find_boardinfo(struct comedi_device *dev,
1554                                          struct pci_dev *pcidev)
1555 {
1556         const struct me4000_board *thisboard;
1557         int i;
1558
1559         for (i = 0; i < ARRAY_SIZE(me4000_boards); i++) {
1560                 thisboard = &me4000_boards[i];
1561                 if (thisboard->device_id == pcidev->device)
1562                         return thisboard;
1563         }
1564         return NULL;
1565 }
1566
1567 static int me4000_auto_attach(struct comedi_device *dev,
1568                                         unsigned long context_unused)
1569 {
1570         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1571         const struct me4000_board *thisboard;
1572         struct me4000_info *info;
1573         struct comedi_subdevice *s;
1574         int result;
1575
1576         thisboard = me4000_find_boardinfo(dev, pcidev);
1577         if (!thisboard)
1578                 return -ENODEV;
1579         dev->board_ptr = thisboard;
1580         dev->board_name = thisboard->name;
1581
1582         info = kzalloc(sizeof(*info), GFP_KERNEL);
1583         if (!info)
1584                 return -ENOMEM;
1585         dev->private = info;
1586
1587         result = comedi_pci_enable(pcidev, dev->board_name);
1588         if (result)
1589                 return result;
1590
1591         info->plx_regbase = pci_resource_start(pcidev, 1);
1592         dev->iobase = pci_resource_start(pcidev, 2);
1593         info->timer_regbase = pci_resource_start(pcidev, 3);
1594         if (!info->plx_regbase || !dev->iobase || !info->timer_regbase)
1595                 return -ENODEV;
1596
1597         result = xilinx_download(dev);
1598         if (result)
1599                 return result;
1600
1601         me4000_reset(dev);
1602
1603         result = comedi_alloc_subdevices(dev, 4);
1604         if (result)
1605                 return result;
1606
1607     /*=========================================================================
1608       Analog input subdevice
1609       ========================================================================*/
1610
1611         s = &dev->subdevices[0];
1612
1613         if (thisboard->ai_nchan) {
1614                 s->type = COMEDI_SUBD_AI;
1615                 s->subdev_flags =
1616                     SDF_READABLE | SDF_COMMON | SDF_GROUND | SDF_DIFF;
1617                 s->n_chan = thisboard->ai_nchan;
1618                 s->maxdata = 0xFFFF;    /*  16 bit ADC */
1619                 s->len_chanlist = ME4000_AI_CHANNEL_LIST_COUNT;
1620                 s->range_table = &me4000_ai_range;
1621                 s->insn_read = me4000_ai_insn_read;
1622
1623                 if (pcidev->irq > 0) {
1624                         if (request_irq(pcidev->irq, me4000_ai_isr,
1625                                         IRQF_SHARED, dev->board_name, dev)) {
1626                                 dev_warn(dev->class_dev,
1627                                         "request_irq failed\n");
1628                         } else {
1629                                 dev->read_subdev = s;
1630                                 s->subdev_flags |= SDF_CMD_READ;
1631                                 s->cancel = me4000_ai_cancel;
1632                                 s->do_cmdtest = me4000_ai_do_cmd_test;
1633                                 s->do_cmd = me4000_ai_do_cmd;
1634
1635                                 dev->irq = pcidev->irq;
1636                         }
1637                 } else {
1638                         dev_warn(dev->class_dev, "No interrupt available\n");
1639                 }
1640         } else {
1641                 s->type = COMEDI_SUBD_UNUSED;
1642         }
1643
1644     /*=========================================================================
1645       Analog output subdevice
1646       ========================================================================*/
1647
1648         s = &dev->subdevices[1];
1649
1650         if (thisboard->ao_nchan) {
1651                 s->type = COMEDI_SUBD_AO;
1652                 s->subdev_flags = SDF_WRITEABLE | SDF_COMMON | SDF_GROUND;
1653                 s->n_chan = thisboard->ao_nchan;
1654                 s->maxdata = 0xFFFF;    /*  16 bit DAC */
1655                 s->range_table = &range_bipolar10;
1656                 s->insn_write = me4000_ao_insn_write;
1657                 s->insn_read = me4000_ao_insn_read;
1658         } else {
1659                 s->type = COMEDI_SUBD_UNUSED;
1660         }
1661
1662     /*=========================================================================
1663       Digital I/O subdevice
1664       ========================================================================*/
1665
1666         s = &dev->subdevices[2];
1667
1668         if (thisboard->dio_nchan) {
1669                 s->type = COMEDI_SUBD_DIO;
1670                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
1671                 s->n_chan = thisboard->dio_nchan;
1672                 s->maxdata = 1;
1673                 s->range_table = &range_digital;
1674                 s->insn_bits = me4000_dio_insn_bits;
1675                 s->insn_config = me4000_dio_insn_config;
1676         } else {
1677                 s->type = COMEDI_SUBD_UNUSED;
1678         }
1679
1680         /*
1681          * Check for optoisolated ME-4000 version. If one the first
1682          * port is a fixed output port and the second is a fixed input port.
1683          */
1684         if (!inl(dev->iobase + ME4000_DIO_DIR_REG)) {
1685                 s->io_bits |= 0xFF;
1686                 outl(ME4000_DIO_CTRL_BIT_MODE_0,
1687                         dev->iobase + ME4000_DIO_DIR_REG);
1688         }
1689
1690     /*=========================================================================
1691       Counter subdevice
1692       ========================================================================*/
1693
1694         s = &dev->subdevices[3];
1695
1696         if (thisboard->has_counter) {
1697                 s->type = COMEDI_SUBD_COUNTER;
1698                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
1699                 s->n_chan = 3;
1700                 s->maxdata = 0xFFFF;    /*  16 bit counters */
1701                 s->insn_read = me4000_cnt_insn_read;
1702                 s->insn_write = me4000_cnt_insn_write;
1703                 s->insn_config = me4000_cnt_insn_config;
1704         } else {
1705                 s->type = COMEDI_SUBD_UNUSED;
1706         }
1707
1708         return 0;
1709 }
1710
1711 static void me4000_detach(struct comedi_device *dev)
1712 {
1713         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1714
1715         if (dev->irq)
1716                 free_irq(dev->irq, dev);
1717         if (pcidev) {
1718                 if (dev->iobase) {
1719                         me4000_reset(dev);
1720                         comedi_pci_disable(pcidev);
1721                 }
1722         }
1723 }
1724
1725 static struct comedi_driver me4000_driver = {
1726         .driver_name    = "me4000",
1727         .module         = THIS_MODULE,
1728         .auto_attach    = me4000_auto_attach,
1729         .detach         = me4000_detach,
1730 };
1731
1732 static int me4000_pci_probe(struct pci_dev *dev,
1733                                       const struct pci_device_id *ent)
1734 {
1735         return comedi_pci_auto_config(dev, &me4000_driver);
1736 }
1737
1738 static DEFINE_PCI_DEVICE_TABLE(me4000_pci_table) = {
1739         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4650)},
1740         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4660)},
1741         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4660I)},
1742         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4660S)},
1743         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4660IS)},
1744         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4670)},
1745         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4670I)},
1746         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4670S)},
1747         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4670IS)},
1748         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4680)},
1749         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4680I)},
1750         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4680S)},
1751         {PCI_DEVICE(PCI_VENDOR_ID_MEILHAUS, PCI_DEVICE_ID_MEILHAUS_ME4680IS)},
1752         {0}
1753 };
1754 MODULE_DEVICE_TABLE(pci, me4000_pci_table);
1755
1756 static struct pci_driver me4000_pci_driver = {
1757         .name           = "me4000",
1758         .id_table       = me4000_pci_table,
1759         .probe          = me4000_pci_probe,
1760         .remove         = comedi_pci_auto_unconfig,
1761 };
1762 module_comedi_pci_driver(me4000_driver, me4000_pci_driver);
1763
1764 MODULE_AUTHOR("Comedi http://www.comedi.org");
1765 MODULE_DESCRIPTION("Comedi low-level driver");
1766 MODULE_LICENSE("GPL");