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:
  39
  40     [0] - PCI bus number (optional)
  41     [1] - PCI slot number (optional)
  42
  43     If bus/slot is not specified, the first available PCI
  44     device will be used.
  45
  46 The firmware required by these boards is available in the
  47 comedi_nonfree_firmware tarball available from
  48 http://www.comedi.org.  However, the driver's support for
  49 loading the firmware through comedi_config is currently
  50 broken.
  51
  52  */
  53
  54 #include <linux/interrupt.h>
  55 #include "../comedidev.h"
  56
  57 #include <linux/delay.h>
  58 #include <linux/list.h>
  59 #include <linux/spinlock.h>
  60
  61 #include "comedi_pci.h"
  62 #include "me4000.h"
  63 #if 0
  64 /* file removed due to GPL incompatibility */
  65 #include "me4000_fw.h"
  66 #endif
  67
  68 /*=============================================================================
  69   PCI device table.
  70   This is used by modprobe to translate PCI IDs to drivers.
  71   ===========================================================================*/
  72
  73 static DEFINE_PCI_DEVICE_TABLE(me4000_pci_table) = {
  74         {
  75         PCI_VENDOR_ID_MEILHAUS, 0x4650, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  76         PCI_VENDOR_ID_MEILHAUS, 0x4660, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  77         PCI_VENDOR_ID_MEILHAUS, 0x4661, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  78         PCI_VENDOR_ID_MEILHAUS, 0x4662, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  79         PCI_VENDOR_ID_MEILHAUS, 0x4663, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  80         PCI_VENDOR_ID_MEILHAUS, 0x4670, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  81         PCI_VENDOR_ID_MEILHAUS, 0x4671, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  82         PCI_VENDOR_ID_MEILHAUS, 0x4672, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  83         PCI_VENDOR_ID_MEILHAUS, 0x4673, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  84         PCI_VENDOR_ID_MEILHAUS, 0x4680, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  85         PCI_VENDOR_ID_MEILHAUS, 0x4681, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  86         PCI_VENDOR_ID_MEILHAUS, 0x4682, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  87         PCI_VENDOR_ID_MEILHAUS, 0x4683, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  88         0}
  89 };
  90
  91 MODULE_DEVICE_TABLE(pci, me4000_pci_table);
  92
  93 static const struct me4000_board me4000_boards[] = {
  94         {"ME-4650", 0x4650, {0, 0}, {16, 0, 0, 0}, {4}, {0} },
  95
  96         {"ME-4660", 0x4660, {0, 0}, {32, 0, 16, 0}, {4}, {3} },
  97         {"ME-4660i", 0x4661, {0, 0}, {32, 0, 16, 0}, {4}, {3} },
  98         {"ME-4660s", 0x4662, {0, 0}, {32, 8, 16, 0}, {4}, {3} },
  99         {"ME-4660is", 0x4663, {0, 0}, {32, 8, 16, 0}, {4}, {3} },
 100
 101         {"ME-4670", 0x4670, {4, 0}, {32, 0, 16, 1}, {4}, {3} },
 102         {"ME-4670i", 0x4671, {4, 0}, {32, 0, 16, 1}, {4}, {3} },
 103         {"ME-4670s", 0x4672, {4, 0}, {32, 8, 16, 1}, {4}, {3} },
 104         {"ME-4670is", 0x4673, {4, 0}, {32, 8, 16, 1}, {4}, {3} },
 105
 106         {"ME-4680", 0x4680, {4, 4}, {32, 0, 16, 1}, {4}, {3} },
 107         {"ME-4680i", 0x4681, {4, 4}, {32, 0, 16, 1}, {4}, {3} },
 108         {"ME-4680s", 0x4682, {4, 4}, {32, 8, 16, 1}, {4}, {3} },
 109         {"ME-4680is", 0x4683, {4, 4}, {32, 8, 16, 1}, {4}, {3} },
 110
 111         {0},
 112 };
 113
 114 #define ME4000_BOARD_VERSIONS (ARRAY_SIZE(me4000_boards) - 1)
 115
 116 /*-----------------------------------------------------------------------------
 117   Comedi function prototypes
 118   ---------------------------------------------------------------------------*/
 119 static int me4000_attach(struct comedi_device *dev,
 120                          struct comedi_devconfig *it);
 121 static int me4000_detach(struct comedi_device *dev);
 122 static struct comedi_driver driver_me4000 = {
 123 driver_name: "me4000",
 124 module : THIS_MODULE,
 125 attach : me4000_attach,
 126 detach : me4000_detach,
 127 };
 128
 129 /*-----------------------------------------------------------------------------
 130   Meilhaus function prototypes
 131   ---------------------------------------------------------------------------*/
 132 static int me4000_probe(struct comedi_device *dev, struct comedi_devconfig *it);
 133 static int get_registers(struct comedi_device *dev, struct pci_dev *pci_dev_p);
 134 static int init_board_info(struct comedi_device *dev,
 135                            struct pci_dev *pci_dev_p);
 136 static int init_ao_context(struct comedi_device *dev);
 137 static int init_ai_context(struct comedi_device *dev);
 138 static int init_dio_context(struct comedi_device *dev);
 139 static int init_cnt_context(struct comedi_device *dev);
 140 static int xilinx_download(struct comedi_device *dev);
 141 static int reset_board(struct comedi_device *dev);
 142
 143 static int me4000_dio_insn_bits(struct comedi_device *dev,
 144                                 struct comedi_subdevice *s,
 145                                 struct comedi_insn *insn, unsigned int *data);
 146
 147 static int me4000_dio_insn_config(struct comedi_device *dev,
 148                                   struct comedi_subdevice *s,
 149                                   struct comedi_insn *insn, unsigned int *data);
 150
 151 static int cnt_reset(struct comedi_device *dev, unsigned int channel);
 152
 153 static int cnt_config(struct comedi_device *dev,
 154                       unsigned int channel, unsigned int mode);
 155
 156 static int me4000_cnt_insn_config(struct comedi_device *dev,
 157                                   struct comedi_subdevice *s,
 158                                   struct comedi_insn *insn, unsigned int *data);
 159
 160 static int me4000_cnt_insn_write(struct comedi_device *dev,
 161                                  struct comedi_subdevice *s,
 162                                  struct comedi_insn *insn, unsigned int *data);
 163
 164 static int me4000_cnt_insn_read(struct comedi_device *dev,
 165                                 struct comedi_subdevice *s,
 166                                 struct comedi_insn *insn, unsigned int *data);
 167
 168 static int me4000_ai_insn_read(struct comedi_device *dev,
 169                                struct comedi_subdevice *subdevice,
 170                                struct comedi_insn *insn, unsigned int *data);
 171
 172 static int me4000_ai_cancel(struct comedi_device *dev,
 173                             struct comedi_subdevice *s);
 174
 175 static int ai_check_chanlist(struct comedi_device *dev,
 176                              struct comedi_subdevice *s,
 177                              struct comedi_cmd *cmd);
 178
 179 static int ai_round_cmd_args(struct comedi_device *dev,
 180                              struct comedi_subdevice *s,
 181                              struct comedi_cmd *cmd,
 182                              unsigned int *init_ticks,
 183                              unsigned int *scan_ticks,
 184                              unsigned int *chan_ticks);
 185
 186 static int ai_prepare(struct comedi_device *dev,
 187                       struct comedi_subdevice *s,
 188                       struct comedi_cmd *cmd,
 189                       unsigned int init_ticks,
 190                       unsigned int scan_ticks, unsigned int chan_ticks);
 191
 192 static int ai_write_chanlist(struct comedi_device *dev,
 193                              struct comedi_subdevice *s,
 194                              struct comedi_cmd *cmd);
 195
 196 static irqreturn_t me4000_ai_isr(int irq, void *dev_id);
 197
 198 static int me4000_ai_do_cmd_test(struct comedi_device *dev,
 199                                  struct comedi_subdevice *s,
 200                                  struct comedi_cmd *cmd);
 201
 202 static int me4000_ai_do_cmd(struct comedi_device *dev,
 203                             struct comedi_subdevice *s);
 204
 205 static int me4000_ao_insn_write(struct comedi_device *dev,
 206                                 struct comedi_subdevice *s,
 207                                 struct comedi_insn *insn, unsigned int *data);
 208
 209 static int me4000_ao_insn_read(struct comedi_device *dev,
 210                                struct comedi_subdevice *s,
 211                                struct comedi_insn *insn, unsigned int *data);
 212
 213 /*-----------------------------------------------------------------------------
 214   Meilhaus inline functions
 215   ---------------------------------------------------------------------------*/
 216
 217 static inline void me4000_outb(struct comedi_device *dev, unsigned char value,
 218                                unsigned long port)
 219 {
 220         PORT_PDEBUG("--> 0x%02X port 0x%04lX\n", value, port);
 221         outb(value, port);
 222 }
 223
 224 static inline void me4000_outl(struct comedi_device *dev, unsigned long value,
 225                                unsigned long port)
 226 {
 227         PORT_PDEBUG("--> 0x%08lX port 0x%04lX\n", value, port);
 228         outl(value, port);
 229 }
 230
 231 static inline unsigned long me4000_inl(struct comedi_device *dev,
 232                                        unsigned long port)
 233 {
 234         unsigned long value;
 235         value = inl(port);
 236         PORT_PDEBUG("<-- 0x%08lX port 0x%04lX\n", value, port);
 237         return value;
 238 }
 239
 240 static inline unsigned char me4000_inb(struct comedi_device *dev,
 241                                        unsigned long port)
 242 {
 243         unsigned char value;
 244         value = inb(port);
 245         PORT_PDEBUG("<-- 0x%08X port 0x%04lX\n", value, port);
 246         return value;
 247 }
 248
 249 static const struct comedi_lrange me4000_ai_range = {
 250         4,
 251         {
 252          UNI_RANGE(2.5),
 253          UNI_RANGE(10),
 254          BIP_RANGE(2.5),
 255          BIP_RANGE(10),
 256          }
 257 };
 258
 259 static const struct comedi_lrange me4000_ao_range = {
 260         1,
 261         {
 262          BIP_RANGE(10),
 263          }
 264 };
 265
 266 static int me4000_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 267 {
 268         struct comedi_subdevice *s;
 269         int result;
 270
 271         CALL_PDEBUG("In me4000_attach()\n");
 272
 273         result = me4000_probe(dev, it);
 274         if (result)
 275                 return result;
 276
 277         /*
 278          * Allocate the subdevice structures.  alloc_subdevice() is a
 279          * convenient macro defined in comedidev.h.  It relies on
 280          * n_subdevices being set correctly.
 281          */
 282         if (alloc_subdevices(dev, 4) < 0)
 283                 return -ENOMEM;
 284
 285     /*=========================================================================
 286       Analog input subdevice
 287       ========================================================================*/
 288
 289         s = dev->subdevices + 0;
 290
 291         if (thisboard->ai.count) {
 292                 s->type = COMEDI_SUBD_AI;
 293                 s->subdev_flags =
 294                     SDF_READABLE | SDF_COMMON | SDF_GROUND | SDF_DIFF;
 295                 s->n_chan = thisboard->ai.count;
 296                 s->maxdata = 0xFFFF;    /*  16 bit ADC */
 297                 s->len_chanlist = ME4000_AI_CHANNEL_LIST_COUNT;
 298                 s->range_table = &me4000_ai_range;
 299                 s->insn_read = me4000_ai_insn_read;
 300
 301                 if (info->irq > 0) {
 302                         if (request_irq(info->irq, me4000_ai_isr,
 303                                         IRQF_SHARED, "ME-4000", dev)) {
 304                                 printk
 305                                     ("comedi%d: me4000: me4000_attach(): "
 306                                      "Unable to allocate irq\n", dev->minor);
 307                         } else {
 308                                 dev->read_subdev = s;
 309                                 s->subdev_flags |= SDF_CMD_READ;
 310                                 s->cancel = me4000_ai_cancel;
 311                                 s->do_cmdtest = me4000_ai_do_cmd_test;
 312                                 s->do_cmd = me4000_ai_do_cmd;
 313                         }
 314                 } else {
 315                         printk(KERN_WARNING
 316                                "comedi%d: me4000: me4000_attach(): "
 317                                "No interrupt available\n", dev->minor);
 318                 }
 319         } else {
 320                 s->type = COMEDI_SUBD_UNUSED;
 321         }
 322
 323     /*=========================================================================
 324       Analog output subdevice
 325       ========================================================================*/
 326
 327         s = dev->subdevices + 1;
 328
 329         if (thisboard->ao.count) {
 330                 s->type = COMEDI_SUBD_AO;
 331                 s->subdev_flags = SDF_WRITEABLE | SDF_COMMON | SDF_GROUND;
 332                 s->n_chan = thisboard->ao.count;
 333                 s->maxdata = 0xFFFF;    /*  16 bit DAC */
 334                 s->range_table = &me4000_ao_range;
 335                 s->insn_write = me4000_ao_insn_write;
 336                 s->insn_read = me4000_ao_insn_read;
 337         } else {
 338                 s->type = COMEDI_SUBD_UNUSED;
 339         }
 340
 341     /*=========================================================================
 342       Digital I/O subdevice
 343       ========================================================================*/
 344
 345         s = dev->subdevices + 2;
 346
 347         if (thisboard->dio.count) {
 348                 s->type = COMEDI_SUBD_DIO;
 349                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 350                 s->n_chan = thisboard->dio.count * 8;
 351                 s->maxdata = 1;
 352                 s->range_table = &range_digital;
 353                 s->insn_bits = me4000_dio_insn_bits;
 354                 s->insn_config = me4000_dio_insn_config;
 355         } else {
 356                 s->type = COMEDI_SUBD_UNUSED;
 357         }
 358
 359         /*
 360          * Check for optoisolated ME-4000 version. If one the first
 361          * port is a fixed output port and the second is a fixed input port.
 362          */
 363         if (!me4000_inl(dev, info->dio_context.dir_reg)) {
 364                 s->io_bits |= 0xFF;
 365                 me4000_outl(dev, ME4000_DIO_CTRL_BIT_MODE_0,
 366                             info->dio_context.dir_reg);
 367         }
 368
 369     /*=========================================================================
 370       Counter subdevice
 371       ========================================================================*/
 372
 373         s = dev->subdevices + 3;
 374
 375         if (thisboard->cnt.count) {
 376                 s->type = COMEDI_SUBD_COUNTER;
 377                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 378                 s->n_chan = thisboard->cnt.count;
 379                 s->maxdata = 0xFFFF;    /*  16 bit counters */
 380                 s->insn_read = me4000_cnt_insn_read;
 381                 s->insn_write = me4000_cnt_insn_write;
 382                 s->insn_config = me4000_cnt_insn_config;
 383         } else {
 384                 s->type = COMEDI_SUBD_UNUSED;
 385         }
 386
 387         return 0;
 388 }
 389
 390 static int me4000_probe(struct comedi_device *dev, struct comedi_devconfig *it)
 391 {
 392         struct pci_dev *pci_device;
 393         int result, i;
 394         struct me4000_board *board;
 395
 396         CALL_PDEBUG("In me4000_probe()\n");
 397
 398         /* Allocate private memory */
 399         if (alloc_private(dev, sizeof(struct me4000_info)) < 0)
 400                 return -ENOMEM;
 401
 402         /*
 403          * Probe the device to determine what device in the series it is.
 404          */
 405         for (pci_device = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
 406              pci_device != NULL;
 407              pci_device = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pci_device)) {
 408                 if (pci_device->vendor == PCI_VENDOR_ID_MEILHAUS) {
 409                         for (i = 0; i < ME4000_BOARD_VERSIONS; i++) {
 410                                 if (me4000_boards[i].device_id ==
 411                                     pci_device->device) {
 412                                         /*
 413                                          * Was a particular
 414                                          * bus/slot requested?
 415                                          */
 416                                         if ((it->options[0] != 0)
 417                                             || (it->options[1] != 0)) {
 418                                                 /*
 419                                                  * Are we on the wrong
 420                                                  * bus/slot?
 421                                                  */
 422                                                 if (pci_device->bus->number !=
 423                                                     it->options[0]
 424                                                     ||
 425                                                     PCI_SLOT(pci_device->devfn)
 426                                                     != it->options[1]) {
 427                                                         continue;
 428                                                 }
 429                                         }
 430                                         dev->board_ptr = me4000_boards + i;
 431                                         board =
 432                                             (struct me4000_board *)
 433                                             dev->board_ptr;
 434                                         info->pci_dev_p = pci_device;
 435                                         goto found;
 436                                 }
 437                         }
 438                 }
 439         }
 440
 441         printk(KERN_ERR
 442                "comedi%d: me4000: me4000_probe(): "
 443                "No supported board found (req. bus/slot : %d/%d)\n",
 444                dev->minor, it->options[0], it->options[1]);
 445         return -ENODEV;
 446
 447 found:
 448
 449         printk(KERN_INFO
 450                "comedi%d: me4000: me4000_probe(): "
 451                "Found %s at PCI bus %d, slot %d\n",
 452                dev->minor, me4000_boards[i].name, pci_device->bus->number,
 453                PCI_SLOT(pci_device->devfn));
 454
 455         /* Set data in device structure */
 456         dev->board_name = board->name;
 457
 458         /* Enable PCI device and request regions */
 459         result = comedi_pci_enable(pci_device, dev->board_name);
 460         if (result) {
 461                 printk(KERN_ERR
 462                        "comedi%d: me4000: me4000_probe(): Cannot enable PCI "
 463                        "device and request I/O regions\n", dev->minor);
 464                 return result;
 465         }
 466
 467         /* Get the PCI base registers */
 468         result = get_registers(dev, pci_device);
 469         if (result) {
 470                 printk(KERN_ERR
 471                        "comedi%d: me4000: me4000_probe(): "
 472                        "Cannot get registers\n", dev->minor);
 473                 return result;
 474         }
 475         /* Initialize board info */
 476         result = init_board_info(dev, pci_device);
 477         if (result) {
 478                 printk(KERN_ERR
 479                        "comedi%d: me4000: me4000_probe(): "
 480                        "Cannot init baord info\n", dev->minor);
 481                 return result;
 482         }
 483
 484         /* Init analog output context */
 485         result = init_ao_context(dev);
 486         if (result) {
 487                 printk(KERN_ERR
 488                        "comedi%d: me4000: me4000_probe(): "
 489                        "Cannot init ao context\n", dev->minor);
 490                 return result;
 491         }
 492
 493         /* Init analog input context */
 494         result = init_ai_context(dev);
 495         if (result) {
 496                 printk(KERN_ERR
 497                        "comedi%d: me4000: me4000_probe(): "
 498                        "Cannot init ai context\n", dev->minor);
 499                 return result;
 500         }
 501
 502         /* Init digital I/O context */
 503         result = init_dio_context(dev);
 504         if (result) {
 505                 printk(KERN_ERR
 506                        "comedi%d: me4000: me4000_probe(): "
 507                        "Cannot init dio context\n", dev->minor);
 508                 return result;
 509         }
 510
 511         /* Init counter context */
 512         result = init_cnt_context(dev);
 513         if (result) {
 514                 printk(KERN_ERR
 515                        "comedi%d: me4000: me4000_probe(): "
 516                        "Cannot init cnt context\n", dev->minor);
 517                 return result;
 518         }
 519
 520         /* Download the xilinx firmware */
 521         result = xilinx_download(dev);
 522         if (result) {
 523                 printk(KERN_ERR
 524                        "comedi%d: me4000: me4000_probe(): "
 525                        "Can't download firmware\n", dev->minor);
 526                 return result;
 527         }
 528
 529         /* Make a hardware reset */
 530         result = reset_board(dev);
 531         if (result) {
 532                 printk(KERN_ERR
 533                        "comedi%d: me4000: me4000_probe(): Can't reset board\n",
 534                        dev->minor);
 535                 return result;
 536         }
 537
 538         return 0;
 539 }
 540
 541 static int get_registers(struct comedi_device *dev, struct pci_dev *pci_dev_p)
 542 {
 543
 544         CALL_PDEBUG("In get_registers()\n");
 545
 546     /*--------------------------- plx regbase -------------------------------*/
 547
 548         info->plx_regbase = pci_resource_start(pci_dev_p, 1);
 549         if (info->plx_regbase == 0) {
 550                 printk(KERN_ERR
 551                        "comedi%d: me4000: get_registers(): "
 552                        "PCI base address 1 is not available\n", dev->minor);
 553                 return -ENODEV;
 554         }
 555         info->plx_regbase_size = pci_resource_len(pci_dev_p, 1);
 556
 557     /*--------------------------- me4000 regbase ----------------------------*/
 558
 559         info->me4000_regbase = pci_resource_start(pci_dev_p, 2);
 560         if (info->me4000_regbase == 0) {
 561                 printk(KERN_ERR
 562                        "comedi%d: me4000: get_registers(): "
 563                        "PCI base address 2 is not available\n", dev->minor);
 564                 return -ENODEV;
 565         }
 566         info->me4000_regbase_size = pci_resource_len(pci_dev_p, 2);
 567
 568     /*--------------------------- timer regbase ------------------------------*/
 569
 570         info->timer_regbase = pci_resource_start(pci_dev_p, 3);
 571         if (info->timer_regbase == 0) {
 572                 printk(KERN_ERR
 573                        "comedi%d: me4000: get_registers(): "
 574                        "PCI base address 3 is not available\n", dev->minor);
 575                 return -ENODEV;
 576         }
 577         info->timer_regbase_size = pci_resource_len(pci_dev_p, 3);
 578
 579     /*--------------------------- program regbase ----------------------------*/
 580
 581         info->program_regbase = pci_resource_start(pci_dev_p, 5);
 582         if (info->program_regbase == 0) {
 583                 printk(KERN_ERR
 584                        "comedi%d: me4000: get_registers(): "
 585                        "PCI base address 5 is not available\n", dev->minor);
 586                 return -ENODEV;
 587         }
 588         info->program_regbase_size = pci_resource_len(pci_dev_p, 5);
 589
 590         return 0;
 591 }
 592
 593 static int init_board_info(struct comedi_device *dev, struct pci_dev *pci_dev_p)
 594 {
 595         int result;
 596
 597         CALL_PDEBUG("In init_board_info()\n");
 598
 599         /* Init spin locks */
 600         /* spin_lock_init(&info->preload_lock); */
 601         /* spin_lock_init(&info->ai_ctrl_lock); */
 602
 603         /* Get the serial number */
 604         result = pci_read_config_dword(pci_dev_p, 0x2C, &info->serial_no);
 605         if (result != PCIBIOS_SUCCESSFUL)
 606                 return result;
 607
 608         /* Get the hardware revision */
 609         result = pci_read_config_byte(pci_dev_p, 0x08, &info->hw_revision);
 610         if (result != PCIBIOS_SUCCESSFUL)
 611                 return result;
 612
 613         /* Get the vendor id */
 614         info->vendor_id = pci_dev_p->vendor;
 615
 616         /* Get the device id */
 617         info->device_id = pci_dev_p->device;
 618
 619         /* Get the irq assigned to the board */
 620         info->irq = pci_dev_p->irq;
 621
 622         return 0;
 623 }
 624
 625 static int init_ao_context(struct comedi_device *dev)
 626 {
 627         int i;
 628
 629         CALL_PDEBUG("In init_ao_context()\n");
 630
 631         for (i = 0; i < thisboard->ao.count; i++) {
 632                 /* spin_lock_init(&info->ao_context[i].use_lock); */
 633                 info->ao_context[i].irq = info->irq;
 634
 635                 switch (i) {
 636                 case 0:
 637                         info->ao_context[i].ctrl_reg =
 638                             info->me4000_regbase + ME4000_AO_00_CTRL_REG;
 639                         info->ao_context[i].status_reg =
 640                             info->me4000_regbase + ME4000_AO_00_STATUS_REG;
 641                         info->ao_context[i].fifo_reg =
 642                             info->me4000_regbase + ME4000_AO_00_FIFO_REG;
 643                         info->ao_context[i].single_reg =
 644                             info->me4000_regbase + ME4000_AO_00_SINGLE_REG;
 645                         info->ao_context[i].timer_reg =
 646                             info->me4000_regbase + ME4000_AO_00_TIMER_REG;
 647                         info->ao_context[i].irq_status_reg =
 648                             info->me4000_regbase + ME4000_IRQ_STATUS_REG;
 649                         info->ao_context[i].preload_reg =
 650                             info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
 651                         break;
 652                 case 1:
 653                         info->ao_context[i].ctrl_reg =
 654                             info->me4000_regbase + ME4000_AO_01_CTRL_REG;
 655                         info->ao_context[i].status_reg =
 656                             info->me4000_regbase + ME4000_AO_01_STATUS_REG;
 657                         info->ao_context[i].fifo_reg =
 658                             info->me4000_regbase + ME4000_AO_01_FIFO_REG;
 659                         info->ao_context[i].single_reg =
 660                             info->me4000_regbase + ME4000_AO_01_SINGLE_REG;
 661                         info->ao_context[i].timer_reg =
 662                             info->me4000_regbase + ME4000_AO_01_TIMER_REG;
 663                         info->ao_context[i].irq_status_reg =
 664                             info->me4000_regbase + ME4000_IRQ_STATUS_REG;
 665                         info->ao_context[i].preload_reg =
 666                             info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
 667                         break;
 668                 case 2:
 669                         info->ao_context[i].ctrl_reg =
 670                             info->me4000_regbase + ME4000_AO_02_CTRL_REG;
 671                         info->ao_context[i].status_reg =
 672                             info->me4000_regbase + ME4000_AO_02_STATUS_REG;
 673                         info->ao_context[i].fifo_reg =
 674                             info->me4000_regbase + ME4000_AO_02_FIFO_REG;
 675                         info->ao_context[i].single_reg =
 676                             info->me4000_regbase + ME4000_AO_02_SINGLE_REG;
 677                         info->ao_context[i].timer_reg =
 678                             info->me4000_regbase + ME4000_AO_02_TIMER_REG;
 679                         info->ao_context[i].irq_status_reg =
 680                             info->me4000_regbase + ME4000_IRQ_STATUS_REG;
 681                         info->ao_context[i].preload_reg =
 682                             info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
 683                         break;
 684                 case 3:
 685                         info->ao_context[i].ctrl_reg =
 686                             info->me4000_regbase + ME4000_AO_03_CTRL_REG;
 687                         info->ao_context[i].status_reg =
 688                             info->me4000_regbase + ME4000_AO_03_STATUS_REG;
 689                         info->ao_context[i].fifo_reg =
 690                             info->me4000_regbase + ME4000_AO_03_FIFO_REG;
 691                         info->ao_context[i].single_reg =
 692                             info->me4000_regbase + ME4000_AO_03_SINGLE_REG;
 693                         info->ao_context[i].timer_reg =
 694                             info->me4000_regbase + ME4000_AO_03_TIMER_REG;
 695                         info->ao_context[i].irq_status_reg =
 696                             info->me4000_regbase + ME4000_IRQ_STATUS_REG;
 697                         info->ao_context[i].preload_reg =
 698                             info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
 699                         break;
 700                 default:
 701                         break;
 702                 }
 703         }
 704
 705         return 0;
 706 }
 707
 708 static int init_ai_context(struct comedi_device *dev)
 709 {
 710
 711         CALL_PDEBUG("In init_ai_context()\n");
 712
 713         info->ai_context.irq = info->irq;
 714
 715         info->ai_context.ctrl_reg = info->me4000_regbase + ME4000_AI_CTRL_REG;
 716         info->ai_context.status_reg =
 717             info->me4000_regbase + ME4000_AI_STATUS_REG;
 718         info->ai_context.channel_list_reg =
 719             info->me4000_regbase + ME4000_AI_CHANNEL_LIST_REG;
 720         info->ai_context.data_reg = info->me4000_regbase + ME4000_AI_DATA_REG;
 721         info->ai_context.chan_timer_reg =
 722             info->me4000_regbase + ME4000_AI_CHAN_TIMER_REG;
 723         info->ai_context.chan_pre_timer_reg =
 724             info->me4000_regbase + ME4000_AI_CHAN_PRE_TIMER_REG;
 725         info->ai_context.scan_timer_low_reg =
 726             info->me4000_regbase + ME4000_AI_SCAN_TIMER_LOW_REG;
 727         info->ai_context.scan_timer_high_reg =
 728             info->me4000_regbase + ME4000_AI_SCAN_TIMER_HIGH_REG;
 729         info->ai_context.scan_pre_timer_low_reg =
 730             info->me4000_regbase + ME4000_AI_SCAN_PRE_TIMER_LOW_REG;
 731         info->ai_context.scan_pre_timer_high_reg =
 732             info->me4000_regbase + ME4000_AI_SCAN_PRE_TIMER_HIGH_REG;
 733         info->ai_context.start_reg = info->me4000_regbase + ME4000_AI_START_REG;
 734         info->ai_context.irq_status_reg =
 735             info->me4000_regbase + ME4000_IRQ_STATUS_REG;
 736         info->ai_context.sample_counter_reg =
 737             info->me4000_regbase + ME4000_AI_SAMPLE_COUNTER_REG;
 738
 739         return 0;
 740 }
 741
 742 static int init_dio_context(struct comedi_device *dev)
 743 {
 744
 745         CALL_PDEBUG("In init_dio_context()\n");
 746
 747         info->dio_context.dir_reg = info->me4000_regbase + ME4000_DIO_DIR_REG;
 748         info->dio_context.ctrl_reg = info->me4000_regbase + ME4000_DIO_CTRL_REG;
 749         info->dio_context.port_0_reg =
 750             info->me4000_regbase + ME4000_DIO_PORT_0_REG;
 751         info->dio_context.port_1_reg =
 752             info->me4000_regbase + ME4000_DIO_PORT_1_REG;
 753         info->dio_context.port_2_reg =
 754             info->me4000_regbase + ME4000_DIO_PORT_2_REG;
 755         info->dio_context.port_3_reg =
 756             info->me4000_regbase + ME4000_DIO_PORT_3_REG;
 757
 758         return 0;
 759 }
 760
 761 static int init_cnt_context(struct comedi_device *dev)
 762 {
 763
 764         CALL_PDEBUG("In init_cnt_context()\n");
 765
 766         info->cnt_context.ctrl_reg = info->timer_regbase + ME4000_CNT_CTRL_REG;
 767         info->cnt_context.counter_0_reg =
 768             info->timer_regbase + ME4000_CNT_COUNTER_0_REG;
 769         info->cnt_context.counter_1_reg =
 770             info->timer_regbase + ME4000_CNT_COUNTER_1_REG;
 771         info->cnt_context.counter_2_reg =
 772             info->timer_regbase + ME4000_CNT_COUNTER_2_REG;
 773
 774         return 0;
 775 }
 776
 777 #define FIRMWARE_NOT_AVAILABLE 1
 778 #if FIRMWARE_NOT_AVAILABLE
 779 extern unsigned char *xilinx_firm;
 780 #endif
 781
 782 static int xilinx_download(struct comedi_device *dev)
 783 {
 784         u32 value = 0;
 785         wait_queue_head_t queue;
 786         int idx = 0;
 787         int size = 0;
 788
 789         CALL_PDEBUG("In xilinx_download()\n");
 790
 791         init_waitqueue_head(&queue);
 792
 793         /*
 794          * Set PLX local interrupt 2 polarity to high.
 795          * Interrupt is thrown by init pin of xilinx.
 796          */
 797         outl(0x10, info->plx_regbase + PLX_INTCSR);
 798
 799         /* Set /CS and /WRITE of the Xilinx */
 800         value = inl(info->plx_regbase + PLX_ICR);
 801         value |= 0x100;
 802         outl(value, info->plx_regbase + PLX_ICR);
 803
 804         /* Init Xilinx with CS1 */
 805         inb(info->program_regbase + 0xC8);
 806
 807         /* Wait until /INIT pin is set */
 808         udelay(20);
 809         if (!(inl(info->plx_regbase + PLX_INTCSR) & 0x20)) {
 810                 printk(KERN_ERR
 811                        "comedi%d: me4000: xilinx_download(): "
 812                        "Can't init Xilinx\n", dev->minor);
 813                 return -EIO;
 814         }
 815
 816         /* Reset /CS and /WRITE of the Xilinx */
 817         value = inl(info->plx_regbase + PLX_ICR);
 818         value &= ~0x100;
 819         outl(value, info->plx_regbase + PLX_ICR);
 820         if (FIRMWARE_NOT_AVAILABLE) {
 821                 comedi_error(dev, "xilinx firmware unavailable "
 822                              "due to licensing, aborting");
 823                 return -EIO;
 824         } else {
 825                 /* Download Xilinx firmware */
 826                 size = (xilinx_firm[0] << 24) + (xilinx_firm[1] << 16) +
 827                     (xilinx_firm[2] << 8) + xilinx_firm[3];
 828                 udelay(10);
 829
 830                 for (idx = 0; idx < size; idx++) {
 831                         outb(xilinx_firm[16 + idx], info->program_regbase);
 832                         udelay(10);
 833
 834                         /* Check if BUSY flag is low */
 835                         if (inl(info->plx_regbase + PLX_ICR) & 0x20) {
 836                                 printk(KERN_ERR
 837                                        "comedi%d: me4000: xilinx_download(): "
 838                                        "Xilinx is still busy (idx = %d)\n",
 839                                        dev->minor, idx);
 840                                 return -EIO;
 841                         }
 842                 }
 843         }
 844
 845         /* If done flag is high download was successful */
 846         if (inl(info->plx_regbase + PLX_ICR) & 0x4) {
 847         } else {
 848                 printk(KERN_ERR
 849                        "comedi%d: me4000: xilinx_download(): "
 850                        "DONE flag is not set\n", dev->minor);
 851                 printk(KERN_ERR
 852                        "comedi%d: me4000: xilinx_download(): "
 853                        "Download not successful\n", dev->minor);
 854                 return -EIO;
 855         }
 856
 857         /* Set /CS and /WRITE */
 858         value = inl(info->plx_regbase + PLX_ICR);
 859         value |= 0x100;
 860         outl(value, info->plx_regbase + PLX_ICR);
 861
 862         return 0;
 863 }
 864
 865 static int reset_board(struct comedi_device *dev)
 866 {
 867         unsigned long icr;
 868
 869         CALL_PDEBUG("In reset_board()\n");
 870
 871         /* Make a hardware reset */
 872         icr = me4000_inl(dev, info->plx_regbase + PLX_ICR);
 873         icr |= 0x40000000;
 874         me4000_outl(dev, icr, info->plx_regbase + PLX_ICR);
 875         icr &= ~0x40000000;
 876         me4000_outl(dev, icr, info->plx_regbase + PLX_ICR);
 877
 878         /* 0x8000 to the DACs means an output voltage of 0V */
 879         me4000_outl(dev, 0x8000,
 880                     info->me4000_regbase + ME4000_AO_00_SINGLE_REG);
 881         me4000_outl(dev, 0x8000,
 882                     info->me4000_regbase + ME4000_AO_01_SINGLE_REG);
 883         me4000_outl(dev, 0x8000,
 884                     info->me4000_regbase + ME4000_AO_02_SINGLE_REG);
 885         me4000_outl(dev, 0x8000,
 886                     info->me4000_regbase + ME4000_AO_03_SINGLE_REG);
 887
 888         /* Set both stop bits in the analog input control register */
 889         me4000_outl(dev,
 890                     ME4000_AI_CTRL_BIT_IMMEDIATE_STOP | ME4000_AI_CTRL_BIT_STOP,
 891                     info->me4000_regbase + ME4000_AI_CTRL_REG);
 892
 893         /* Set both stop bits in the analog output control register */
 894         me4000_outl(dev,
 895                     ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
 896                     info->me4000_regbase + ME4000_AO_00_CTRL_REG);
 897         me4000_outl(dev,
 898                     ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
 899                     info->me4000_regbase + ME4000_AO_01_CTRL_REG);
 900         me4000_outl(dev,
 901                     ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
 902                     info->me4000_regbase + ME4000_AO_02_CTRL_REG);
 903         me4000_outl(dev,
 904                     ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
 905                     info->me4000_regbase + ME4000_AO_03_CTRL_REG);
 906
 907         /* Enable interrupts on the PLX */
 908         me4000_outl(dev, 0x43, info->plx_regbase + PLX_INTCSR);
 909
 910         /* Set the adustment register for AO demux */
 911         me4000_outl(dev, ME4000_AO_DEMUX_ADJUST_VALUE,
 912                     info->me4000_regbase + ME4000_AO_DEMUX_ADJUST_REG);
 913
 914         /*
 915          * Set digital I/O direction for port 0
 916          * to output on isolated versions
 917          */
 918         if (!(me4000_inl(dev, info->me4000_regbase + ME4000_DIO_DIR_REG) & 0x1)) {
 919                 me4000_outl(dev, 0x1,
 920                             info->me4000_regbase + ME4000_DIO_CTRL_REG);
 921         }
 922
 923         return 0;
 924 }
 925
 926 static int me4000_detach(struct comedi_device *dev)
 927 {
 928         CALL_PDEBUG("In me4000_detach()\n");
 929
 930         if (info) {
 931                 if (info->pci_dev_p) {
 932                         reset_board(dev);
 933                         if (info->plx_regbase)
 934                                 comedi_pci_disable(info->pci_dev_p);
 935                         pci_dev_put(info->pci_dev_p);
 936                 }
 937         }
 938
 939         return 0;
 940 }
 941
 942 /*=============================================================================
 943   Analog input section
 944   ===========================================================================*/
 945
 946 static int me4000_ai_insn_read(struct comedi_device *dev,
 947                                struct comedi_subdevice *subdevice,
 948                                struct comedi_insn *insn, unsigned int *data)
 949 {
 950
 951         int chan = CR_CHAN(insn->chanspec);
 952         int rang = CR_RANGE(insn->chanspec);
 953         int aref = CR_AREF(insn->chanspec);
 954
 955         unsigned long entry = 0;
 956         unsigned long tmp;
 957         long lval;
 958
 959         CALL_PDEBUG("In me4000_ai_insn_read()\n");
 960
 961         if (insn->n == 0) {
 962                 return 0;
 963         } else if (insn->n > 1) {
 964                 printk(KERN_ERR
 965                        "comedi%d: me4000: me4000_ai_insn_read(): "
 966                        "Invalid instruction length %d\n", dev->minor, insn->n);
 967                 return -EINVAL;
 968         }
 969
 970         switch (rang) {
 971         case 0:
 972                 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_2_5;
 973                 break;
 974         case 1:
 975                 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_10;
 976                 break;
 977         case 2:
 978                 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_2_5;
 979                 break;
 980         case 3:
 981                 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_10;
 982                 break;
 983         default:
 984                 printk(KERN_ERR
 985                        "comedi%d: me4000: me4000_ai_insn_read(): "
 986                        "Invalid range specified\n", dev->minor);
 987                 return -EINVAL;
 988         }
 989
 990         switch (aref) {
 991         case AREF_GROUND:
 992         case AREF_COMMON:
 993                 if (chan >= thisboard->ai.count) {
 994                         printk(KERN_ERR
 995                                "comedi%d: me4000: me4000_ai_insn_read(): "
 996                                "Analog input is not available\n", dev->minor);
 997                         return -EINVAL;
 998                 }
 999                 entry |= ME4000_AI_LIST_INPUT_SINGLE_ENDED | chan;
1000                 break;
1001
1002         case AREF_DIFF:
1003                 if (rang == 0 || rang == 1) {
1004                         printk(KERN_ERR
1005                                "comedi%d: me4000: me4000_ai_insn_read(): "
1006                                "Range must be bipolar when aref = diff\n",
1007                                dev->minor);
1008                         return -EINVAL;
1009                 }
1010
1011                 if (chan >= thisboard->ai.diff_count) {
1012                         printk(KERN_ERR
1013                                "comedi%d: me4000: me4000_ai_insn_read(): "
1014                                "Analog input is not available\n", dev->minor);
1015                         return -EINVAL;
1016                 }
1017                 entry |= ME4000_AI_LIST_INPUT_DIFFERENTIAL | chan;
1018                 break;
1019         default:
1020                 printk(KERN_ERR
1021                        "comedi%d: me4000: me4000_ai_insn_read(): "
1022                        "Invalid aref specified\n", dev->minor);
1023                 return -EINVAL;
1024         }
1025
1026         entry |= ME4000_AI_LIST_LAST_ENTRY;
1027
1028         /* Clear channel list, data fifo and both stop bits */
1029         tmp = me4000_inl(dev, info->ai_context.ctrl_reg);
1030         tmp &= ~(ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1031                  ME4000_AI_CTRL_BIT_DATA_FIFO |
1032                  ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
1033         me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1034
1035         /* Set the acquisition mode to single */
1036         tmp &= ~(ME4000_AI_CTRL_BIT_MODE_0 | ME4000_AI_CTRL_BIT_MODE_1 |
1037                  ME4000_AI_CTRL_BIT_MODE_2);
1038         me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1039
1040         /* Enable channel list and data fifo */
1041         tmp |= ME4000_AI_CTRL_BIT_CHANNEL_FIFO | ME4000_AI_CTRL_BIT_DATA_FIFO;
1042         me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1043
1044         /* Generate channel list entry */
1045         me4000_outl(dev, entry, info->ai_context.channel_list_reg);
1046
1047         /* Set the timer to maximum sample rate */
1048         me4000_outl(dev, ME4000_AI_MIN_TICKS, info->ai_context.chan_timer_reg);
1049         me4000_outl(dev, ME4000_AI_MIN_TICKS,
1050                     info->ai_context.chan_pre_timer_reg);
1051
1052         /* Start conversion by dummy read */
1053         me4000_inl(dev, info->ai_context.start_reg);
1054
1055         /* Wait until ready */
1056         udelay(10);
1057         if (!
1058             (me4000_inl(dev, info->ai_context.status_reg) &
1059              ME4000_AI_STATUS_BIT_EF_DATA)) {
1060                 printk(KERN_ERR
1061                        "comedi%d: me4000: me4000_ai_insn_read(): "
1062                        "Value not available after wait\n", dev->minor);
1063                 return -EIO;
1064         }
1065
1066         /* Read value from data fifo */
1067         lval = me4000_inl(dev, info->ai_context.data_reg) & 0xFFFF;
1068         data[0] = lval ^ 0x8000;
1069
1070         return 1;
1071 }
1072
1073 static int me4000_ai_cancel(struct comedi_device *dev,
1074                             struct comedi_subdevice *s)
1075 {
1076         unsigned long tmp;
1077
1078         CALL_PDEBUG("In me4000_ai_cancel()\n");
1079
1080         /* Stop any running conversion */
1081         tmp = me4000_inl(dev, info->ai_context.ctrl_reg);
1082         tmp &= ~(ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
1083         me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1084
1085         /* Clear the control register */
1086         me4000_outl(dev, 0x0, info->ai_context.ctrl_reg);
1087
1088         return 0;
1089 }
1090
1091 static int ai_check_chanlist(struct comedi_device *dev,
1092                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
1093 {
1094         int aref;
1095         int i;
1096
1097         CALL_PDEBUG("In ai_check_chanlist()\n");
1098
1099         /* Check whether a channel list is available */
1100         if (!cmd->chanlist_len) {
1101                 printk(KERN_ERR
1102                        "comedi%d: me4000: ai_check_chanlist(): "
1103                        "No channel list available\n", dev->minor);
1104                 return -EINVAL;
1105         }
1106
1107         /* Check the channel list size */
1108         if (cmd->chanlist_len > ME4000_AI_CHANNEL_LIST_COUNT) {
1109                 printk(KERN_ERR
1110                        "comedi%d: me4000: ai_check_chanlist(): "
1111                        "Channel list is to large\n", dev->minor);
1112                 return -EINVAL;
1113         }
1114
1115         /* Check the pointer */
1116         if (!cmd->chanlist) {
1117                 printk(KERN_ERR
1118                        "comedi%d: me4000: ai_check_chanlist(): "
1119                        "NULL pointer to channel list\n", dev->minor);
1120                 return -EFAULT;
1121         }
1122
1123         /* Check whether aref is equal for all entries */
1124         aref = CR_AREF(cmd->chanlist[0]);
1125         for (i = 0; i < cmd->chanlist_len; i++) {
1126                 if (CR_AREF(cmd->chanlist[i]) != aref) {
1127                         printk(KERN_ERR
1128                                "comedi%d: me4000: ai_check_chanlist(): "
1129                                "Mode is not equal for all entries\n",
1130                                dev->minor);
1131                         return -EINVAL;
1132                 }
1133         }
1134
1135         /* Check whether channels are available for this ending */
1136         if (aref == SDF_DIFF) {
1137                 for (i = 0; i < cmd->chanlist_len; i++) {
1138                         if (CR_CHAN(cmd->chanlist[i]) >=
1139                             thisboard->ai.diff_count) {
1140                                 printk(KERN_ERR
1141                                        "comedi%d: me4000: ai_check_chanlist():"
1142                                        " Channel number to high\n", dev->minor);
1143                                 return -EINVAL;
1144                         }
1145                 }
1146         } else {
1147                 for (i = 0; i < cmd->chanlist_len; i++) {
1148                         if (CR_CHAN(cmd->chanlist[i]) >= thisboard->ai.count) {
1149                                 printk(KERN_ERR
1150                                        "comedi%d: me4000: ai_check_chanlist(): "
1151                                        "Channel number to high\n", dev->minor);
1152                                 return -EINVAL;
1153                         }
1154                 }
1155         }
1156
1157         /* Check if bipolar is set for all entries when in differential mode */
1158         if (aref == SDF_DIFF) {
1159                 for (i = 0; i < cmd->chanlist_len; i++) {
1160                         if (CR_RANGE(cmd->chanlist[i]) != 1 &&
1161                             CR_RANGE(cmd->chanlist[i]) != 2) {
1162                                 printk(KERN_ERR
1163                                        "comedi%d: me4000: ai_check_chanlist(): "
1164                                        "Bipolar is not selected in "
1165                                        "differential mode\n",
1166                                        dev->minor);
1167                                 return -EINVAL;
1168                         }
1169                 }
1170         }
1171
1172         return 0;
1173 }
1174
1175 static int ai_round_cmd_args(struct comedi_device *dev,
1176                              struct comedi_subdevice *s,
1177                              struct comedi_cmd *cmd,
1178                              unsigned int *init_ticks,
1179                              unsigned int *scan_ticks, unsigned int *chan_ticks)
1180 {
1181
1182         int rest;
1183
1184         CALL_PDEBUG("In ai_round_cmd_args()\n");
1185
1186         *init_ticks = 0;
1187         *scan_ticks = 0;
1188         *chan_ticks = 0;
1189
1190         PDEBUG("ai_round_cmd_arg(): start_arg = %d\n", cmd->start_arg);
1191         PDEBUG("ai_round_cmd_arg(): scan_begin_arg = %d\n",
1192                cmd->scan_begin_arg);
1193         PDEBUG("ai_round_cmd_arg(): convert_arg = %d\n", cmd->convert_arg);
1194
1195         if (cmd->start_arg) {
1196                 *init_ticks = (cmd->start_arg * 33) / 1000;
1197                 rest = (cmd->start_arg * 33) % 1000;
1198
1199                 if (cmd->flags & TRIG_ROUND_NEAREST) {
1200                         if (rest > 33)
1201                                 (*init_ticks)++;
1202                 } else if (cmd->flags & TRIG_ROUND_UP) {
1203                         if (rest)
1204                                 (*init_ticks)++;
1205                 }
1206         }
1207
1208         if (cmd->scan_begin_arg) {
1209                 *scan_ticks = (cmd->scan_begin_arg * 33) / 1000;
1210                 rest = (cmd->scan_begin_arg * 33) % 1000;
1211
1212                 if (cmd->flags & TRIG_ROUND_NEAREST) {
1213                         if (rest > 33)
1214                                 (*scan_ticks)++;
1215                 } else if (cmd->flags & TRIG_ROUND_UP) {
1216                         if (rest)
1217                                 (*scan_ticks)++;
1218                 }
1219         }
1220
1221         if (cmd->convert_arg) {
1222                 *chan_ticks = (cmd->convert_arg * 33) / 1000;
1223                 rest = (cmd->convert_arg * 33) % 1000;
1224
1225                 if (cmd->flags & TRIG_ROUND_NEAREST) {
1226                         if (rest > 33)
1227                                 (*chan_ticks)++;
1228                 } else if (cmd->flags & TRIG_ROUND_UP) {
1229                         if (rest)
1230                                 (*chan_ticks)++;
1231                 }
1232         }
1233
1234         PDEBUG("ai_round_cmd_args(): init_ticks = %d\n", *init_ticks);
1235         PDEBUG("ai_round_cmd_args(): scan_ticks = %d\n", *scan_ticks);
1236         PDEBUG("ai_round_cmd_args(): chan_ticks = %d\n", *chan_ticks);
1237
1238         return 0;
1239 }
1240
1241 static void ai_write_timer(struct comedi_device *dev,
1242                            unsigned int init_ticks,
1243                            unsigned int scan_ticks, unsigned int chan_ticks)
1244 {
1245
1246         CALL_PDEBUG("In ai_write_timer()\n");
1247
1248         me4000_outl(dev, init_ticks - 1,
1249                     info->ai_context.scan_pre_timer_low_reg);
1250         me4000_outl(dev, 0x0, info->ai_context.scan_pre_timer_high_reg);
1251
1252         if (scan_ticks) {
1253                 me4000_outl(dev, scan_ticks - 1,
1254                             info->ai_context.scan_timer_low_reg);
1255                 me4000_outl(dev, 0x0, info->ai_context.scan_timer_high_reg);
1256         }
1257
1258         me4000_outl(dev, chan_ticks - 1, info->ai_context.chan_pre_timer_reg);
1259         me4000_outl(dev, chan_ticks - 1, info->ai_context.chan_timer_reg);
1260 }
1261
1262 static int ai_prepare(struct comedi_device *dev,
1263                       struct comedi_subdevice *s,
1264                       struct comedi_cmd *cmd,
1265                       unsigned int init_ticks,
1266                       unsigned int scan_ticks, unsigned int chan_ticks)
1267 {
1268
1269         unsigned long tmp = 0;
1270
1271         CALL_PDEBUG("In ai_prepare()\n");
1272
1273         /* Write timer arguments */
1274         ai_write_timer(dev, init_ticks, scan_ticks, chan_ticks);
1275
1276         /* Reset control register */
1277         me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1278
1279         /* Start sources */
1280         if ((cmd->start_src == TRIG_EXT &&
1281              cmd->scan_begin_src == TRIG_TIMER &&
1282              cmd->convert_src == TRIG_TIMER) ||
1283             (cmd->start_src == TRIG_EXT &&
1284              cmd->scan_begin_src == TRIG_FOLLOW &&
1285              cmd->convert_src == TRIG_TIMER)) {
1286                 tmp = ME4000_AI_CTRL_BIT_MODE_1 |
1287                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1288                     ME4000_AI_CTRL_BIT_DATA_FIFO;
1289         } else if (cmd->start_src == TRIG_EXT &&
1290                    cmd->scan_begin_src == TRIG_EXT &&
1291                    cmd->convert_src == TRIG_TIMER) {
1292                 tmp = ME4000_AI_CTRL_BIT_MODE_2 |
1293                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1294                     ME4000_AI_CTRL_BIT_DATA_FIFO;
1295         } else if (cmd->start_src == TRIG_EXT &&
1296                    cmd->scan_begin_src == TRIG_EXT &&
1297                    cmd->convert_src == TRIG_EXT) {
1298                 tmp = ME4000_AI_CTRL_BIT_MODE_0 |
1299                     ME4000_AI_CTRL_BIT_MODE_1 |
1300                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1301                     ME4000_AI_CTRL_BIT_DATA_FIFO;
1302         } else {
1303                 tmp = ME4000_AI_CTRL_BIT_MODE_0 |
1304                     ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1305                     ME4000_AI_CTRL_BIT_DATA_FIFO;
1306         }
1307
1308         /* Stop triggers */
1309         if (cmd->stop_src == TRIG_COUNT) {
1310                 me4000_outl(dev, cmd->chanlist_len * cmd->stop_arg,
1311                             info->ai_context.sample_counter_reg);
1312                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
1313         } else if (cmd->stop_src == TRIG_NONE &&
1314                    cmd->scan_end_src == TRIG_COUNT) {
1315                 me4000_outl(dev, cmd->scan_end_arg,
1316                             info->ai_context.sample_counter_reg);
1317                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
1318         } else {
1319                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ;
1320         }
1321
1322         /* Write the setup to the control register */
1323         me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1324
1325         /* Write the channel list */
1326         ai_write_chanlist(dev, s, cmd);
1327
1328         return 0;
1329 }
1330
1331 static int ai_write_chanlist(struct comedi_device *dev,
1332                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
1333 {
1334         unsigned int entry;
1335         unsigned int chan;
1336         unsigned int rang;
1337         unsigned int aref;
1338         int i;
1339
1340         CALL_PDEBUG("In ai_write_chanlist()\n");
1341
1342         for (i = 0; i < cmd->chanlist_len; i++) {
1343                 chan = CR_CHAN(cmd->chanlist[i]);
1344                 rang = CR_RANGE(cmd->chanlist[i]);
1345                 aref = CR_AREF(cmd->chanlist[i]);
1346
1347                 entry = chan;
1348
1349                 if (rang == 0)
1350                         entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_2_5;
1351                 else if (rang == 1)
1352                         entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_10;
1353                 else if (rang == 2)
1354                         entry |= ME4000_AI_LIST_RANGE_BIPOLAR_2_5;
1355                 else
1356                         entry |= ME4000_AI_LIST_RANGE_BIPOLAR_10;
1357
1358                 if (aref == SDF_DIFF)
1359                         entry |= ME4000_AI_LIST_INPUT_DIFFERENTIAL;
1360                 else
1361                         entry |= ME4000_AI_LIST_INPUT_SINGLE_ENDED;
1362
1363                 me4000_outl(dev, entry, info->ai_context.channel_list_reg);
1364         }
1365
1366         return 0;
1367 }
1368
1369 static int me4000_ai_do_cmd(struct comedi_device *dev,
1370                             struct comedi_subdevice *s)
1371 {
1372         int err;
1373         unsigned int init_ticks = 0;
1374         unsigned int scan_ticks = 0;
1375         unsigned int chan_ticks = 0;
1376         struct comedi_cmd *cmd = &s->async->cmd;
1377
1378         CALL_PDEBUG("In me4000_ai_do_cmd()\n");
1379
1380         /* Reset the analog input */
1381         err = me4000_ai_cancel(dev, s);
1382         if (err)
1383                 return err;
1384
1385         /* Round the timer arguments */
1386         err = ai_round_cmd_args(dev,
1387                                 s, cmd, &init_ticks, &scan_ticks, &chan_ticks);
1388         if (err)
1389                 return err;
1390
1391         /* Prepare the AI for acquisition */
1392         err = ai_prepare(dev, s, cmd, init_ticks, scan_ticks, chan_ticks);
1393         if (err)
1394                 return err;
1395
1396         /* Start acquistion by dummy read */
1397         me4000_inl(dev, info->ai_context.start_reg);
1398
1399         return 0;
1400 }
1401
1402 /*
1403  * me4000_ai_do_cmd_test():
1404  *
1405  * The demo cmd.c in ./comedilib/demo specifies 6 return values:
1406  * - success
1407  * - invalid source
1408  * - source conflict
1409  * - invalid argument
1410  * - argument conflict
1411  * - invalid chanlist
1412  * So I tried to adopt this scheme.
1413  */
1414 static int me4000_ai_do_cmd_test(struct comedi_device *dev,
1415                                  struct comedi_subdevice *s,
1416                                  struct comedi_cmd *cmd)
1417 {
1418
1419         unsigned int init_ticks;
1420         unsigned int chan_ticks;
1421         unsigned int scan_ticks;
1422         int err = 0;
1423
1424         CALL_PDEBUG("In me4000_ai_do_cmd_test()\n");
1425
1426         PDEBUG("me4000_ai_do_cmd_test(): subdev         = %d\n", cmd->subdev);
1427         PDEBUG("me4000_ai_do_cmd_test(): flags          = %08X\n", cmd->flags);
1428         PDEBUG("me4000_ai_do_cmd_test(): start_src      = %08X\n",
1429                cmd->start_src);
1430         PDEBUG("me4000_ai_do_cmd_test(): start_arg      = %d\n",
1431                cmd->start_arg);
1432         PDEBUG("me4000_ai_do_cmd_test(): scan_begin_src = %08X\n",
1433                cmd->scan_begin_src);
1434         PDEBUG("me4000_ai_do_cmd_test(): scan_begin_arg = %d\n",
1435                cmd->scan_begin_arg);
1436         PDEBUG("me4000_ai_do_cmd_test(): convert_src    = %08X\n",
1437                cmd->convert_src);
1438         PDEBUG("me4000_ai_do_cmd_test(): convert_arg    = %d\n",
1439                cmd->convert_arg);
1440         PDEBUG("me4000_ai_do_cmd_test(): scan_end_src   = %08X\n",
1441                cmd->scan_end_src);
1442         PDEBUG("me4000_ai_do_cmd_test(): scan_end_arg   = %d\n",
1443                cmd->scan_end_arg);
1444         PDEBUG("me4000_ai_do_cmd_test(): stop_src       = %08X\n",
1445                cmd->stop_src);
1446         PDEBUG("me4000_ai_do_cmd_test(): stop_arg       = %d\n", cmd->stop_arg);
1447         PDEBUG("me4000_ai_do_cmd_test(): chanlist       = %d\n",
1448                (unsigned int)cmd->chanlist);
1449         PDEBUG("me4000_ai_do_cmd_test(): chanlist_len   = %d\n",
1450                cmd->chanlist_len);
1451
1452         /* Only rounding flags are implemented */
1453         cmd->flags &= TRIG_ROUND_NEAREST | TRIG_ROUND_UP | TRIG_ROUND_DOWN;
1454
1455         /* Round the timer arguments */
1456         ai_round_cmd_args(dev, s, cmd, &init_ticks, &scan_ticks, &chan_ticks);
1457
1458         /*
1459          * Stage 1. Check if the trigger sources are generally valid.
1460          */
1461         switch (cmd->start_src) {
1462         case TRIG_NOW:
1463         case TRIG_EXT:
1464                 break;
1465         case TRIG_ANY:
1466                 cmd->start_src &= TRIG_NOW | TRIG_EXT;
1467                 err++;
1468                 break;
1469         default:
1470                 printk(KERN_ERR
1471                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1472                        "Invalid start source\n", dev->minor);
1473                 cmd->start_src = TRIG_NOW;
1474                 err++;
1475         }
1476         switch (cmd->scan_begin_src) {
1477         case TRIG_FOLLOW:
1478         case TRIG_TIMER:
1479         case TRIG_EXT:
1480                 break;
1481         case TRIG_ANY:
1482                 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT;
1483                 err++;
1484                 break;
1485         default:
1486                 printk(KERN_ERR
1487                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1488                        "Invalid scan begin source\n", dev->minor);
1489                 cmd->scan_begin_src = TRIG_FOLLOW;
1490                 err++;
1491         }
1492         switch (cmd->convert_src) {
1493         case TRIG_TIMER:
1494         case TRIG_EXT:
1495                 break;
1496         case TRIG_ANY:
1497                 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
1498                 err++;
1499                 break;
1500         default:
1501                 printk(KERN_ERR
1502                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1503                        "Invalid convert source\n", dev->minor);
1504                 cmd->convert_src = TRIG_TIMER;
1505                 err++;
1506         }
1507         switch (cmd->scan_end_src) {
1508         case TRIG_NONE:
1509         case TRIG_COUNT:
1510                 break;
1511         case TRIG_ANY:
1512                 cmd->scan_end_src &= TRIG_NONE | TRIG_COUNT;
1513                 err++;
1514                 break;
1515         default:
1516                 printk(KERN_ERR
1517                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1518                        "Invalid scan end source\n", dev->minor);
1519                 cmd->scan_end_src = TRIG_NONE;
1520                 err++;
1521         }
1522         switch (cmd->stop_src) {
1523         case TRIG_NONE:
1524         case TRIG_COUNT:
1525                 break;
1526         case TRIG_ANY:
1527                 cmd->stop_src &= TRIG_NONE | TRIG_COUNT;
1528                 err++;
1529                 break;
1530         default:
1531                 printk(KERN_ERR
1532                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1533                        "Invalid stop source\n", dev->minor);
1534                 cmd->stop_src = TRIG_NONE;
1535                 err++;
1536         }
1537         if (err)
1538                 return 1;
1539
1540         /*
1541          * Stage 2. Check for trigger source conflicts.
1542          */
1543         if (cmd->start_src == TRIG_NOW &&
1544             cmd->scan_begin_src == TRIG_TIMER &&
1545             cmd->convert_src == TRIG_TIMER) {
1546         } else if (cmd->start_src == TRIG_NOW &&
1547                    cmd->scan_begin_src == TRIG_FOLLOW &&
1548                    cmd->convert_src == TRIG_TIMER) {
1549         } else if (cmd->start_src == TRIG_EXT &&
1550                    cmd->scan_begin_src == TRIG_TIMER &&
1551                    cmd->convert_src == TRIG_TIMER) {
1552         } else if (cmd->start_src == TRIG_EXT &&
1553                    cmd->scan_begin_src == TRIG_FOLLOW &&
1554                    cmd->convert_src == TRIG_TIMER) {
1555         } else if (cmd->start_src == TRIG_EXT &&
1556                    cmd->scan_begin_src == TRIG_EXT &&
1557                    cmd->convert_src == TRIG_TIMER) {
1558         } else if (cmd->start_src == TRIG_EXT &&
1559                    cmd->scan_begin_src == TRIG_EXT &&
1560                    cmd->convert_src == TRIG_EXT) {
1561         } else {
1562                 printk(KERN_ERR
1563                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1564                        "Invalid start trigger combination\n", dev->minor);
1565                 cmd->start_src = TRIG_NOW;
1566                 cmd->scan_begin_src = TRIG_FOLLOW;
1567                 cmd->convert_src = TRIG_TIMER;
1568                 err++;
1569         }
1570
1571         if (cmd->stop_src == TRIG_NONE && cmd->scan_end_src == TRIG_NONE) {
1572         } else if (cmd->stop_src == TRIG_COUNT &&
1573                    cmd->scan_end_src == TRIG_NONE) {
1574         } else if (cmd->stop_src == TRIG_NONE &&
1575                    cmd->scan_end_src == TRIG_COUNT) {
1576         } else if (cmd->stop_src == TRIG_COUNT &&
1577                    cmd->scan_end_src == TRIG_COUNT) {
1578         } else {
1579                 printk(KERN_ERR
1580                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1581                        "Invalid stop trigger combination\n", dev->minor);
1582                 cmd->stop_src = TRIG_NONE;
1583                 cmd->scan_end_src = TRIG_NONE;
1584                 err++;
1585         }
1586         if (err)
1587                 return 2;
1588
1589         /*
1590          * Stage 3. Check if arguments are generally valid.
1591          */
1592         if (cmd->chanlist_len < 1) {
1593                 printk(KERN_ERR
1594                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1595                        "No channel list\n", dev->minor);
1596                 cmd->chanlist_len = 1;
1597                 err++;
1598         }
1599         if (init_ticks < 66) {
1600                 printk(KERN_ERR
1601                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1602                        "Start arg to low\n", dev->minor);
1603                 cmd->start_arg = 2000;
1604                 err++;
1605         }
1606         if (scan_ticks && scan_ticks < 67) {
1607                 printk(KERN_ERR
1608                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1609                        "Scan begin arg to low\n", dev->minor);
1610                 cmd->scan_begin_arg = 2031;
1611                 err++;
1612         }
1613         if (chan_ticks < 66) {
1614                 printk(KERN_ERR
1615                        "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1616                        "Convert arg to low\n", dev->minor);
1617                 cmd->convert_arg = 2000;
1618                 err++;
1619         }
1620
1621         if (err)
1622                 return 3;
1623
1624         /*
1625          * Stage 4. Check for argument conflicts.
1626          */
1627         if (cmd->start_src == TRIG_NOW &&
1628             cmd->scan_begin_src == TRIG_TIMER &&
1629             cmd->convert_src == TRIG_TIMER) {
1630
1631                 /* Check timer arguments */
1632                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1633                         printk(KERN_ERR
1634                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1635                                "Invalid start arg\n", dev->minor);
1636                         cmd->start_arg = 2000;  /*  66 ticks at least */
1637                         err++;
1638                 }
1639                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1640                         printk(KERN_ERR
1641                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1642                                "Invalid convert arg\n", dev->minor);
1643                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1644                         err++;
1645                 }
1646                 if (scan_ticks <= cmd->chanlist_len * chan_ticks) {
1647                         printk(KERN_ERR
1648                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1649                                "Invalid scan end arg\n", dev->minor);
1650
1651                         /*  At least one tick more */
1652                         cmd->scan_end_arg = 2000 * cmd->chanlist_len + 31;
1653                         err++;
1654                 }
1655         } else if (cmd->start_src == TRIG_NOW &&
1656                    cmd->scan_begin_src == TRIG_FOLLOW &&
1657                    cmd->convert_src == TRIG_TIMER) {
1658
1659                 /* Check timer arguments */
1660                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1661                         printk(KERN_ERR
1662                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1663                                "Invalid start arg\n", dev->minor);
1664                         cmd->start_arg = 2000;  /*  66 ticks at least */
1665                         err++;
1666                 }
1667                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1668                         printk(KERN_ERR
1669                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1670                                "Invalid convert arg\n", dev->minor);
1671                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1672                         err++;
1673                 }
1674         } else if (cmd->start_src == TRIG_EXT &&
1675                    cmd->scan_begin_src == TRIG_TIMER &&
1676                    cmd->convert_src == TRIG_TIMER) {
1677
1678                 /* Check timer arguments */
1679                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1680                         printk(KERN_ERR
1681                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1682                                "Invalid start arg\n", dev->minor);
1683                         cmd->start_arg = 2000;  /*  66 ticks at least */
1684                         err++;
1685                 }
1686                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1687                         printk(KERN_ERR
1688                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1689                                "Invalid convert arg\n", dev->minor);
1690                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1691                         err++;
1692                 }
1693                 if (scan_ticks <= cmd->chanlist_len * chan_ticks) {
1694                         printk(KERN_ERR
1695                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1696                                "Invalid scan end arg\n", dev->minor);
1697
1698                         /*  At least one tick more */
1699                         cmd->scan_end_arg = 2000 * cmd->chanlist_len + 31;
1700                         err++;
1701                 }
1702         } else if (cmd->start_src == TRIG_EXT &&
1703                    cmd->scan_begin_src == TRIG_FOLLOW &&
1704                    cmd->convert_src == TRIG_TIMER) {
1705
1706                 /* Check timer arguments */
1707                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1708                         printk(KERN_ERR
1709                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1710                                "Invalid start arg\n", dev->minor);
1711                         cmd->start_arg = 2000;  /*  66 ticks at least */
1712                         err++;
1713                 }
1714                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1715                         printk(KERN_ERR
1716                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1717                                "Invalid convert arg\n", dev->minor);
1718                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1719                         err++;
1720                 }
1721         } else if (cmd->start_src == TRIG_EXT &&
1722                    cmd->scan_begin_src == TRIG_EXT &&
1723                    cmd->convert_src == TRIG_TIMER) {
1724
1725                 /* Check timer arguments */
1726                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1727                         printk(KERN_ERR
1728                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1729                                "Invalid start arg\n", dev->minor);
1730                         cmd->start_arg = 2000;  /*  66 ticks at least */
1731                         err++;
1732                 }
1733                 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1734                         printk(KERN_ERR
1735                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1736                                "Invalid convert arg\n", dev->minor);
1737                         cmd->convert_arg = 2000;        /*  66 ticks at least */
1738                         err++;
1739                 }
1740         } else if (cmd->start_src == TRIG_EXT &&
1741                    cmd->scan_begin_src == TRIG_EXT &&
1742                    cmd->convert_src == TRIG_EXT) {
1743
1744                 /* Check timer arguments */
1745                 if (init_ticks < ME4000_AI_MIN_TICKS) {
1746                         printk(KERN_ERR
1747                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1748                                "Invalid start arg\n", dev->minor);
1749                         cmd->start_arg = 2000;  /*  66 ticks at least */
1750                         err++;
1751                 }
1752         }
1753         if (cmd->stop_src == TRIG_COUNT) {
1754                 if (cmd->stop_arg == 0) {
1755                         printk(KERN_ERR
1756                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1757                                "Invalid stop arg\n", dev->minor);
1758                         cmd->stop_arg = 1;
1759                         err++;
1760                 }
1761         }
1762         if (cmd->scan_end_src == TRIG_COUNT) {
1763                 if (cmd->scan_end_arg == 0) {
1764                         printk(KERN_ERR
1765                                "comedi%d: me4000: me4000_ai_do_cmd_test(): "
1766                                "Invalid scan end arg\n", dev->minor);
1767                         cmd->scan_end_arg = 1;
1768                         err++;
1769                 }
1770         }
1771
1772         if (err)
1773                 return 4;
1774
1775         /*
1776          * Stage 5. Check the channel list.
1777          */
1778         if (ai_check_chanlist(dev, s, cmd))
1779                 return 5;
1780
1781         return 0;
1782 }
1783
1784 static irqreturn_t me4000_ai_isr(int irq, void *dev_id)
1785 {
1786         unsigned int tmp;
1787         struct comedi_device *dev = dev_id;
1788         struct comedi_subdevice *s = dev->subdevices;
1789         struct me4000_ai_context *ai_context = &info->ai_context;
1790         int i;
1791         int c = 0;
1792         long lval;
1793
1794         ISR_PDEBUG("me4000_ai_isr() is executed\n");
1795
1796         if (!dev->attached) {
1797                 ISR_PDEBUG("me4000_ai_isr() premature interrupt\n");
1798                 return IRQ_NONE;
1799         }
1800
1801         /* Reset all events */
1802         s->async->events = 0;
1803
1804         /* Check if irq number is right */
1805         if (irq != ai_context->irq) {
1806                 printk(KERN_ERR
1807                        "comedi%d: me4000: me4000_ai_isr(): "
1808                        "Incorrect interrupt num: %d\n", dev->minor, irq);
1809                 return IRQ_HANDLED;
1810         }
1811
1812         if (me4000_inl(dev,
1813                        ai_context->irq_status_reg) &
1814             ME4000_IRQ_STATUS_BIT_AI_HF) {
1815                 ISR_PDEBUG
1816                     ("me4000_ai_isr(): Fifo half full interrupt occured\n");
1817
1818                 /* Read status register to find out what happened */
1819                 tmp = me4000_inl(dev, ai_context->ctrl_reg);
1820
1821                 if (!(tmp & ME4000_AI_STATUS_BIT_FF_DATA) &&
1822                     !(tmp & ME4000_AI_STATUS_BIT_HF_DATA) &&
1823                     (tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
1824                         ISR_PDEBUG("me4000_ai_isr(): Fifo full\n");
1825                         c = ME4000_AI_FIFO_COUNT;
1826
1827                         /*
1828                          * FIFO overflow, so stop conversion
1829                          * and disable all interrupts
1830                          */
1831                         tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1832                         tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1833                                  ME4000_AI_CTRL_BIT_SC_IRQ);
1834                         me4000_outl(dev, tmp, ai_context->ctrl_reg);
1835
1836                         s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
1837
1838                         printk(KERN_ERR
1839                                "comedi%d: me4000: me4000_ai_isr(): "
1840                                "FIFO overflow\n", dev->minor);
1841                 } else if ((tmp & ME4000_AI_STATUS_BIT_FF_DATA)
1842                            && !(tmp & ME4000_AI_STATUS_BIT_HF_DATA)
1843                            && (tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
1844                         ISR_PDEBUG("me4000_ai_isr(): Fifo half full\n");
1845
1846                         s->async->events |= COMEDI_CB_BLOCK;
1847
1848                         c = ME4000_AI_FIFO_COUNT / 2;
1849                 } else {
1850                         printk(KERN_ERR
1851                                "comedi%d: me4000: me4000_ai_isr(): "
1852                                "Can't determine state of fifo\n", dev->minor);
1853                         c = 0;
1854
1855                         /*
1856                          * Undefined state, so stop conversion
1857                          * and disable all interrupts
1858                          */
1859                         tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1860                         tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1861                                  ME4000_AI_CTRL_BIT_SC_IRQ);
1862                         me4000_outl(dev, tmp, ai_context->ctrl_reg);
1863
1864                         s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
1865
1866                         printk(KERN_ERR
1867                                "comedi%d: me4000: me4000_ai_isr(): "
1868                                "Undefined FIFO state\n", dev->minor);
1869                 }
1870
1871                 ISR_PDEBUG("me4000_ai_isr(): Try to read %d values\n", c);
1872
1873                 for (i = 0; i < c; i++) {
1874                         /* Read value from data fifo */
1875                         lval = inl(ai_context->data_reg) & 0xFFFF;
1876                         lval ^= 0x8000;
1877
1878                         if (!comedi_buf_put(s->async, lval)) {
1879                                 /*
1880                                  * Buffer overflow, so stop conversion
1881                                  * and disable all interrupts
1882                                  */
1883                                 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1884                                 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1885                                          ME4000_AI_CTRL_BIT_SC_IRQ);
1886                                 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1887
1888                                 s->async->events |= COMEDI_CB_OVERFLOW;
1889
1890                                 printk(KERN_ERR
1891                                        "comedi%d: me4000: me4000_ai_isr(): "
1892                                        "Buffer overflow\n", dev->minor);
1893
1894                                 break;
1895                         }
1896                 }
1897
1898                 /* Work is done, so reset the interrupt */
1899                 ISR_PDEBUG("me4000_ai_isr(): Reset fifo half full interrupt\n");
1900                 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
1901                 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1902                 tmp &= ~ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
1903                 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1904         }
1905
1906         if (me4000_inl(dev,
1907                        ai_context->irq_status_reg) & ME4000_IRQ_STATUS_BIT_SC) {
1908                 ISR_PDEBUG
1909                     ("me4000_ai_isr(): Sample counter interrupt occured\n");
1910
1911                 s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOA;
1912
1913                 /*
1914                  * Acquisition is complete, so stop
1915                  * conversion and disable all interrupts
1916                  */
1917                 tmp = me4000_inl(dev, ai_context->ctrl_reg);
1918                 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1919                 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ);
1920                 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1921
1922                 /* Poll data until fifo empty */
1923                 while (inl(ai_context->ctrl_reg) & ME4000_AI_STATUS_BIT_EF_DATA) {
1924                         /* Read value from data fifo */
1925                         lval = inl(ai_context->data_reg) & 0xFFFF;
1926                         lval ^= 0x8000;
1927
1928                         if (!comedi_buf_put(s->async, lval)) {
1929                                 printk(KERN_ERR
1930                                        "comedi%d: me4000: me4000_ai_isr(): "
1931                                        "Buffer overflow\n", dev->minor);
1932                                 s->async->events |= COMEDI_CB_OVERFLOW;
1933                                 break;
1934                         }
1935                 }
1936
1937                 /* Work is done, so reset the interrupt */
1938                 ISR_PDEBUG
1939                     ("me4000_ai_isr(): Reset interrupt from sample counter\n");
1940                 tmp |= ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
1941                 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1942                 tmp &= ~ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
1943                 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1944         }
1945
1946         ISR_PDEBUG("me4000_ai_isr(): Events = 0x%X\n", s->async->events);
1947
1948         if (s->async->events)
1949                 comedi_event(dev, s);
1950
1951         return IRQ_HANDLED;
1952 }
1953
1954 /*=============================================================================
1955   Analog output section
1956   ===========================================================================*/
1957
1958 static int me4000_ao_insn_write(struct comedi_device *dev,
1959                                 struct comedi_subdevice *s,
1960                                 struct comedi_insn *insn, unsigned int *data)
1961 {
1962
1963         int chan = CR_CHAN(insn->chanspec);
1964         int rang = CR_RANGE(insn->chanspec);
1965         int aref = CR_AREF(insn->chanspec);
1966         unsigned long tmp;
1967
1968         CALL_PDEBUG("In me4000_ao_insn_write()\n");
1969
1970         if (insn->n == 0) {
1971                 return 0;
1972         } else if (insn->n > 1) {
1973                 printk(KERN_ERR
1974                        "comedi%d: me4000: me4000_ao_insn_write(): "
1975                        "Invalid instruction length %d\n", dev->minor, insn->n);
1976                 return -EINVAL;
1977         }
1978
1979         if (chan >= thisboard->ao.count) {
1980                 printk(KERN_ERR
1981                        "comedi%d: me4000: me4000_ao_insn_write(): "
1982                        "Invalid channel %d\n", dev->minor, insn->n);
1983                 return -EINVAL;
1984         }
1985
1986         if (rang != 0) {
1987                 printk(KERN_ERR
1988                        "comedi%d: me4000: me4000_ao_insn_write(): "
1989                        "Invalid range %d\n", dev->minor, insn->n);
1990                 return -EINVAL;
1991         }
1992
1993         if (aref != AREF_GROUND && aref != AREF_COMMON) {
1994                 printk(KERN_ERR
1995                        "comedi%d: me4000: me4000_ao_insn_write(): "
1996                        "Invalid aref %d\n", dev->minor, insn->n);
1997                 return -EINVAL;
1998         }
1999
2000         /* Stop any running conversion */
2001         tmp = me4000_inl(dev, info->ao_context[chan].ctrl_reg);
2002         tmp |= ME4000_AO_CTRL_BIT_IMMEDIATE_STOP;
2003         me4000_outl(dev, tmp, info->ao_context[chan].ctrl_reg);
2004
2005         /* Clear control register and set to single mode */
2006         me4000_outl(dev, 0x0, info->ao_context[chan].ctrl_reg);
2007
2008         /* Write data value */
2009         me4000_outl(dev, data[0], info->ao_context[chan].single_reg);
2010
2011         /* Store in the mirror */
2012         info->ao_context[chan].mirror = data[0];
2013
2014         return 1;
2015 }
2016
2017 static int me4000_ao_insn_read(struct comedi_device *dev,
2018                                struct comedi_subdevice *s,
2019                                struct comedi_insn *insn, unsigned int *data)
2020 {
2021         int chan = CR_CHAN(insn->chanspec);
2022
2023         if (insn->n == 0) {
2024                 return 0;
2025         } else if (insn->n > 1) {
2026                 printk
2027                     ("comedi%d: me4000: me4000_ao_insn_read(): "
2028                      "Invalid instruction length\n", dev->minor);
2029                 return -EINVAL;
2030         }
2031
2032         data[0] = info->ao_context[chan].mirror;
2033
2034         return 1;
2035 }
2036
2037 /*=============================================================================
2038   Digital I/O section
2039   ===========================================================================*/
2040
2041 static int me4000_dio_insn_bits(struct comedi_device *dev,
2042                                 struct comedi_subdevice *s,
2043                                 struct comedi_insn *insn, unsigned int *data)
2044 {
2045
2046         CALL_PDEBUG("In me4000_dio_insn_bits()\n");
2047
2048         /* Length of data must be 2 (mask and new data, see below) */
2049         if (insn->n == 0)
2050                 return 0;
2051
2052         if (insn->n != 2) {
2053                 printk
2054                     ("comedi%d: me4000: me4000_dio_insn_bits(): "
2055                      "Invalid instruction length\n", dev->minor);
2056                 return -EINVAL;
2057         }
2058
2059         /*
2060          * The insn data consists of a mask in data[0] and the new data
2061          * in data[1]. The mask defines which bits we are concerning about.
2062          * The new data must be anded with the mask.
2063          * Each channel corresponds to a bit.
2064          */
2065         if (data[0]) {
2066                 /* Check if requested ports are configured for output */
2067                 if ((s->io_bits & data[0]) != data[0])
2068                         return -EIO;
2069
2070                 s->state &= ~data[0];
2071                 s->state |= data[0] & data[1];
2072
2073                 /* Write out the new digital output lines */
2074                 me4000_outl(dev, (s->state >> 0) & 0xFF,
2075                             info->dio_context.port_0_reg);
2076                 me4000_outl(dev, (s->state >> 8) & 0xFF,
2077                             info->dio_context.port_1_reg);
2078                 me4000_outl(dev, (s->state >> 16) & 0xFF,
2079                             info->dio_context.port_2_reg);
2080                 me4000_outl(dev, (s->state >> 24) & 0xFF,
2081                             info->dio_context.port_3_reg);
2082         }
2083
2084         /* On return, data[1] contains the value of
2085            the digital input and output lines. */
2086         data[1] =
2087             ((me4000_inl(dev, info->dio_context.port_0_reg) & 0xFF) << 0) |
2088             ((me4000_inl(dev, info->dio_context.port_1_reg) & 0xFF) << 8) |
2089             ((me4000_inl(dev, info->dio_context.port_2_reg) & 0xFF) << 16) |
2090             ((me4000_inl(dev, info->dio_context.port_3_reg) & 0xFF) << 24);
2091
2092         return 2;
2093 }
2094
2095 static int me4000_dio_insn_config(struct comedi_device *dev,
2096                                   struct comedi_subdevice *s,
2097                                   struct comedi_insn *insn, unsigned int *data)
2098 {
2099         unsigned long tmp;
2100         int chan = CR_CHAN(insn->chanspec);
2101
2102         CALL_PDEBUG("In me4000_dio_insn_config()\n");
2103
2104         if (data[0] == INSN_CONFIG_DIO_QUERY) {
2105                 data[1] =
2106                     (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
2107                 return insn->n;
2108         }
2109
2110         /*
2111          * The input or output configuration of each digital line is
2112          * configured by a special insn_config instruction.  chanspec
2113          * contains the channel to be changed, and data[0] contains the
2114          * value COMEDI_INPUT or COMEDI_OUTPUT.
2115          * On the ME-4000 it is only possible to switch port wise (8 bit)
2116          */
2117
2118         tmp = me4000_inl(dev, info->dio_context.ctrl_reg);
2119
2120         if (data[0] == COMEDI_OUTPUT) {
2121                 if (chan < 8) {
2122                         s->io_bits |= 0xFF;
2123                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_0 |
2124                                  ME4000_DIO_CTRL_BIT_MODE_1);
2125                         tmp |= ME4000_DIO_CTRL_BIT_MODE_0;
2126                 } else if (chan < 16) {
2127                         /*
2128                          * Chech for optoisolated ME-4000 version.
2129                          * If one the first port is a fixed output
2130                          * port and the second is a fixed input port.
2131                          */
2132                         if (!me4000_inl(dev, info->dio_context.dir_reg))
2133                                 return -ENODEV;
2134
2135                         s->io_bits |= 0xFF00;
2136                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_2 |
2137                                  ME4000_DIO_CTRL_BIT_MODE_3);
2138                         tmp |= ME4000_DIO_CTRL_BIT_MODE_2;
2139                 } else if (chan < 24) {
2140                         s->io_bits |= 0xFF0000;
2141                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_4 |
2142                                  ME4000_DIO_CTRL_BIT_MODE_5);
2143                         tmp |= ME4000_DIO_CTRL_BIT_MODE_4;
2144                 } else if (chan < 32) {
2145                         s->io_bits |= 0xFF000000;
2146                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_6 |
2147                                  ME4000_DIO_CTRL_BIT_MODE_7);
2148                         tmp |= ME4000_DIO_CTRL_BIT_MODE_6;
2149                 } else {
2150                         return -EINVAL;
2151                 }
2152         } else {
2153                 if (chan < 8) {
2154                         /*
2155                          * Chech for optoisolated ME-4000 version.
2156                          * If one the first port is a fixed output
2157                          * port and the second is a fixed input port.
2158                          */
2159                         if (!me4000_inl(dev, info->dio_context.dir_reg))
2160                                 return -ENODEV;
2161
2162                         s->io_bits &= ~0xFF;
2163                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_0 |
2164                                  ME4000_DIO_CTRL_BIT_MODE_1);
2165                 } else if (chan < 16) {
2166                         s->io_bits &= ~0xFF00;
2167                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_2 |
2168                                  ME4000_DIO_CTRL_BIT_MODE_3);
2169                 } else if (chan < 24) {
2170                         s->io_bits &= ~0xFF0000;
2171                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_4 |
2172                                  ME4000_DIO_CTRL_BIT_MODE_5);
2173                 } else if (chan < 32) {
2174                         s->io_bits &= ~0xFF000000;
2175                         tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_6 |
2176                                  ME4000_DIO_CTRL_BIT_MODE_7);
2177                 } else {
2178                         return -EINVAL;
2179                 }
2180         }
2181
2182         me4000_outl(dev, tmp, info->dio_context.ctrl_reg);
2183
2184         return 1;
2185 }
2186
2187 /*=============================================================================
2188   Counter section
2189   ===========================================================================*/
2190
2191 static int cnt_reset(struct comedi_device *dev, unsigned int channel)
2192 {
2193
2194         CALL_PDEBUG("In cnt_reset()\n");
2195
2196         switch (channel) {
2197         case 0:
2198                 me4000_outb(dev, 0x30, info->cnt_context.ctrl_reg);
2199                 me4000_outb(dev, 0x00, info->cnt_context.counter_0_reg);
2200                 me4000_outb(dev, 0x00, info->cnt_context.counter_0_reg);
2201                 break;
2202         case 1:
2203                 me4000_outb(dev, 0x70, info->cnt_context.ctrl_reg);
2204                 me4000_outb(dev, 0x00, info->cnt_context.counter_1_reg);
2205                 me4000_outb(dev, 0x00, info->cnt_context.counter_1_reg);
2206                 break;
2207         case 2:
2208                 me4000_outb(dev, 0xB0, info->cnt_context.ctrl_reg);
2209                 me4000_outb(dev, 0x00, info->cnt_context.counter_2_reg);
2210                 me4000_outb(dev, 0x00, info->cnt_context.counter_2_reg);
2211                 break;
2212         default:
2213                 printk(KERN_ERR
2214                        "comedi%d: me4000: cnt_reset(): Invalid channel\n",
2215                        dev->minor);
2216                 return -EINVAL;
2217         }
2218
2219         return 0;
2220 }
2221
2222 static int cnt_config(struct comedi_device *dev, unsigned int channel,
2223                       unsigned int mode)
2224 {
2225         int tmp = 0;
2226
2227         CALL_PDEBUG("In cnt_config()\n");
2228
2229         switch (channel) {
2230         case 0:
2231                 tmp |= ME4000_CNT_COUNTER_0;
2232                 break;
2233         case 1:
2234                 tmp |= ME4000_CNT_COUNTER_1;
2235                 break;
2236         case 2:
2237                 tmp |= ME4000_CNT_COUNTER_2;
2238                 break;
2239         default:
2240                 printk(KERN_ERR
2241                        "comedi%d: me4000: cnt_config(): Invalid channel\n",
2242                        dev->minor);
2243                 return -EINVAL;
2244         }
2245
2246         switch (mode) {
2247         case 0:
2248                 tmp |= ME4000_CNT_MODE_0;
2249                 break;
2250         case 1:
2251                 tmp |= ME4000_CNT_MODE_1;
2252                 break;
2253         case 2:
2254                 tmp |= ME4000_CNT_MODE_2;
2255                 break;
2256         case 3:
2257                 tmp |= ME4000_CNT_MODE_3;
2258                 break;
2259         case 4:
2260                 tmp |= ME4000_CNT_MODE_4;
2261                 break;
2262         case 5:
2263                 tmp |= ME4000_CNT_MODE_5;
2264                 break;
2265         default:
2266                 printk(KERN_ERR
2267                        "comedi%d: me4000: cnt_config(): Invalid counter mode\n",
2268                        dev->minor);
2269                 return -EINVAL;
2270         }
2271
2272         /* Write the control word */
2273         tmp |= 0x30;
2274         me4000_outb(dev, tmp, info->cnt_context.ctrl_reg);
2275
2276         return 0;
2277 }
2278
2279 static int me4000_cnt_insn_config(struct comedi_device *dev,
2280                                   struct comedi_subdevice *s,
2281                                   struct comedi_insn *insn, unsigned int *data)
2282 {
2283
2284         int err;
2285
2286         CALL_PDEBUG("In me4000_cnt_insn_config()\n");
2287
2288         switch (data[0]) {
2289         case GPCT_RESET:
2290                 if (insn->n != 1) {
2291                         printk(KERN_ERR
2292                                "comedi%d: me4000: me4000_cnt_insn_config(): "
2293                                "Invalid instruction length%d\n",
2294                                dev->minor, insn->n);
2295                         return -EINVAL;
2296                 }
2297
2298                 err = cnt_reset(dev, insn->chanspec);
2299                 if (err)
2300                         return err;
2301                 break;
2302         case GPCT_SET_OPERATION:
2303                 if (insn->n != 2) {
2304                         printk(KERN_ERR
2305                                "comedi%d: me4000: me4000_cnt_insn_config(): "
2306                                "Invalid instruction length%d\n",
2307                                dev->minor, insn->n);
2308                         return -EINVAL;
2309                 }
2310
2311                 err = cnt_config(dev, insn->chanspec, data[1]);
2312                 if (err)
2313                         return err;
2314                 break;
2315         default:
2316                 printk(KERN_ERR
2317                        "comedi%d: me4000: me4000_cnt_insn_config(): "
2318                        "Invalid instruction\n", dev->minor);
2319                 return -EINVAL;
2320         }
2321
2322         return 2;
2323 }
2324
2325 static int me4000_cnt_insn_read(struct comedi_device *dev,
2326                                 struct comedi_subdevice *s,
2327                                 struct comedi_insn *insn, unsigned int *data)
2328 {
2329
2330         unsigned short tmp;
2331
2332         CALL_PDEBUG("In me4000_cnt_insn_read()\n");
2333
2334         if (insn->n == 0)
2335                 return 0;
2336
2337         if (insn->n > 1) {
2338                 printk(KERN_ERR
2339                        "comedi%d: me4000: me4000_cnt_insn_read(): "
2340                        "Invalid instruction length %d\n",
2341                        dev->minor, insn->n);
2342                 return -EINVAL;
2343         }
2344
2345         switch (insn->chanspec) {
2346         case 0:
2347                 tmp = me4000_inb(dev, info->cnt_context.counter_0_reg);
2348                 data[0] = tmp;
2349                 tmp = me4000_inb(dev, info->cnt_context.counter_0_reg);
2350                 data[0] |= tmp << 8;
2351                 break;
2352         case 1:
2353                 tmp = me4000_inb(dev, info->cnt_context.counter_1_reg);
2354                 data[0] = tmp;
2355                 tmp = me4000_inb(dev, info->cnt_context.counter_1_reg);
2356                 data[0] |= tmp << 8;
2357                 break;
2358         case 2:
2359                 tmp = me4000_inb(dev, info->cnt_context.counter_2_reg);
2360                 data[0] = tmp;
2361                 tmp = me4000_inb(dev, info->cnt_context.counter_2_reg);
2362                 data[0] |= tmp << 8;
2363                 break;
2364         default:
2365                 printk(KERN_ERR
2366                        "comedi%d: me4000: me4000_cnt_insn_read(): "
2367                        "Invalid channel %d\n",
2368                        dev->minor, insn->chanspec);
2369                 return -EINVAL;
2370         }
2371
2372         return 1;
2373 }
2374
2375 static int me4000_cnt_insn_write(struct comedi_device *dev,
2376                                  struct comedi_subdevice *s,
2377                                  struct comedi_insn *insn, unsigned int *data)
2378 {
2379
2380         unsigned short tmp;
2381
2382         CALL_PDEBUG("In me4000_cnt_insn_write()\n");
2383
2384         if (insn->n == 0) {
2385                 return 0;
2386         } else if (insn->n > 1) {
2387                 printk(KERN_ERR
2388                        "comedi%d: me4000: me4000_cnt_insn_write(): "
2389                        "Invalid instruction length %d\n",
2390                        dev->minor, insn->n);
2391                 return -EINVAL;
2392         }
2393
2394         switch (insn->chanspec) {
2395         case 0:
2396                 tmp = data[0] & 0xFF;
2397                 me4000_outb(dev, tmp, info->cnt_context.counter_0_reg);
2398                 tmp = (data[0] >> 8) & 0xFF;
2399                 me4000_outb(dev, tmp, info->cnt_context.counter_0_reg);
2400                 break;
2401         case 1:
2402                 tmp = data[0] & 0xFF;
2403                 me4000_outb(dev, tmp, info->cnt_context.counter_1_reg);
2404                 tmp = (data[0] >> 8) & 0xFF;
2405                 me4000_outb(dev, tmp, info->cnt_context.counter_1_reg);
2406                 break;
2407         case 2:
2408                 tmp = data[0] & 0xFF;
2409                 me4000_outb(dev, tmp, info->cnt_context.counter_2_reg);
2410                 tmp = (data[0] >> 8) & 0xFF;
2411                 me4000_outb(dev, tmp, info->cnt_context.counter_2_reg);
2412                 break;
2413         default:
2414                 printk(KERN_ERR
2415                        "comedi%d: me4000: me4000_cnt_insn_write(): "
2416                        "Invalid channel %d\n",
2417                        dev->minor, insn->chanspec);
2418                 return -EINVAL;
2419         }
2420
2421         return 1;
2422 }
2423
2424 static int __devinit driver_me4000_pci_probe(struct pci_dev *dev,
2425                                              const struct pci_device_id *ent)
2426 {
2427         return comedi_pci_auto_config(dev, driver_me4000.driver_name);
2428 }
2429
2430 static void __devexit driver_me4000_pci_remove(struct pci_dev *dev)
2431 {
2432         comedi_pci_auto_unconfig(dev);
2433 }
2434
2435 static struct pci_driver driver_me4000_pci_driver = {
2436         .id_table = me4000_pci_table,
2437         .probe = &driver_me4000_pci_probe,
2438         .remove = __devexit_p(&driver_me4000_pci_remove)
2439 };
2440
2441 static int __init driver_me4000_init_module(void)
2442 {
2443         int retval;
2444
2445         retval = comedi_driver_register(&driver_me4000);
2446         if (retval < 0)
2447                 return retval;
2448
2449         driver_me4000_pci_driver.name = (char *)driver_me4000.driver_name;
2450         return pci_register_driver(&driver_me4000_pci_driver);
2451 }
2452
2453 static void __exit driver_me4000_cleanup_module(void)
2454 {
2455         pci_unregister_driver(&driver_me4000_pci_driver);
2456         comedi_driver_unregister(&driver_me4000);
2457 }
2458
2459 module_init(driver_me4000_init_module);
2460 module_exit(driver_me4000_cleanup_module);
2461
2462 MODULE_AUTHOR("Comedi http://www.comedi.org");
2463 MODULE_DESCRIPTION("Comedi low-level driver");
2464 MODULE_LICENSE("GPL");