drivers/staging/comedi/drivers/ni_labpc_common.c

   1 /*
   2  * comedi/drivers/ni_labpc_common.c
   3  *
   4  * Common support code for "ni_labpc", "ni_labpc_pci" and "ni_labpc_cs".
   5  *
   6  * Copyright (C) 2001-2003 Frank Mori Hess <fmhess@users.sourceforge.net>
   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
  19 #include <linux/module.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/io.h>
  22 #include <linux/delay.h>
  23 #include <linux/slab.h>
  24
  25 #include "../comedidev.h"
  26
  27 #include "comedi_8254.h"
  28 #include "8255.h"
  29 #include "ni_labpc.h"
  30 #include "ni_labpc_regs.h"
  31 #include "ni_labpc_isadma.h"
  32
  33 enum scan_mode {
  34         MODE_SINGLE_CHAN,
  35         MODE_SINGLE_CHAN_INTERVAL,
  36         MODE_MULT_CHAN_UP,
  37         MODE_MULT_CHAN_DOWN,
  38 };
  39
  40 static const struct comedi_lrange range_labpc_plus_ai = {
  41         16, {
  42                 BIP_RANGE(5),
  43                 BIP_RANGE(4),
  44                 BIP_RANGE(2.5),
  45                 BIP_RANGE(1),
  46                 BIP_RANGE(0.5),
  47                 BIP_RANGE(0.25),
  48                 BIP_RANGE(0.1),
  49                 BIP_RANGE(0.05),
  50                 UNI_RANGE(10),
  51                 UNI_RANGE(8),
  52                 UNI_RANGE(5),
  53                 UNI_RANGE(2),
  54                 UNI_RANGE(1),
  55                 UNI_RANGE(0.5),
  56                 UNI_RANGE(0.2),
  57                 UNI_RANGE(0.1)
  58         }
  59 };
  60
  61 static const struct comedi_lrange range_labpc_1200_ai = {
  62         14, {
  63                 BIP_RANGE(5),
  64                 BIP_RANGE(2.5),
  65                 BIP_RANGE(1),
  66                 BIP_RANGE(0.5),
  67                 BIP_RANGE(0.25),
  68                 BIP_RANGE(0.1),
  69                 BIP_RANGE(0.05),
  70                 UNI_RANGE(10),
  71                 UNI_RANGE(5),
  72                 UNI_RANGE(2),
  73                 UNI_RANGE(1),
  74                 UNI_RANGE(0.5),
  75                 UNI_RANGE(0.2),
  76                 UNI_RANGE(0.1)
  77         }
  78 };
  79
  80 static const struct comedi_lrange range_labpc_ao = {
  81         2, {
  82                 BIP_RANGE(5),
  83                 UNI_RANGE(10)
  84         }
  85 };
  86
  87 /*
  88  * functions that do inb/outb and readb/writeb so we can use
  89  * function pointers to decide which to use
  90  */
  91 static unsigned int labpc_inb(struct comedi_device *dev, unsigned long reg)
  92 {
  93         return inb(dev->iobase + reg);
  94 }
  95
  96 static void labpc_outb(struct comedi_device *dev,
  97                        unsigned int byte, unsigned long reg)
  98 {
  99         outb(byte, dev->iobase + reg);
 100 }
 101
 102 static unsigned int labpc_readb(struct comedi_device *dev, unsigned long reg)
 103 {
 104         return readb(dev->mmio + reg);
 105 }
 106
 107 static void labpc_writeb(struct comedi_device *dev,
 108                          unsigned int byte, unsigned long reg)
 109 {
 110         writeb(byte, dev->mmio + reg);
 111 }
 112
 113 static int labpc_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
 114 {
 115         struct labpc_private *devpriv = dev->private;
 116         unsigned long flags;
 117
 118         spin_lock_irqsave(&dev->spinlock, flags);
 119         devpriv->cmd2 &= ~(CMD2_SWTRIG | CMD2_HWTRIG | CMD2_PRETRIG);
 120         devpriv->write_byte(dev, devpriv->cmd2, CMD2_REG);
 121         spin_unlock_irqrestore(&dev->spinlock, flags);
 122
 123         devpriv->cmd3 = 0;
 124         devpriv->write_byte(dev, devpriv->cmd3, CMD3_REG);
 125
 126         return 0;
 127 }
 128
 129 static void labpc_ai_set_chan_and_gain(struct comedi_device *dev,
 130                                        enum scan_mode mode,
 131                                        unsigned int chan,
 132                                        unsigned int range,
 133                                        unsigned int aref)
 134 {
 135         const struct labpc_boardinfo *board = dev->board_ptr;
 136         struct labpc_private *devpriv = dev->private;
 137
 138         if (board->is_labpc1200) {
 139                 /*
 140                  * The LabPC-1200 boards do not have a gain
 141                  * of '0x10'. Skip the range values that would
 142                  * result in this gain.
 143                  */
 144                 range += (range > 0) + (range > 7);
 145         }
 146
 147         /* munge channel bits for differential/scan disabled mode */
 148         if ((mode == MODE_SINGLE_CHAN || mode == MODE_SINGLE_CHAN_INTERVAL) &&
 149             aref == AREF_DIFF)
 150                 chan *= 2;
 151         devpriv->cmd1 = CMD1_MA(chan);
 152         devpriv->cmd1 |= CMD1_GAIN(range);
 153
 154         devpriv->write_byte(dev, devpriv->cmd1, CMD1_REG);
 155 }
 156
 157 static void labpc_setup_cmd6_reg(struct comedi_device *dev,
 158                                  struct comedi_subdevice *s,
 159                                  enum scan_mode mode,
 160                                  enum transfer_type xfer,
 161                                  unsigned int range,
 162                                  unsigned int aref,
 163                                  bool ena_intr)
 164 {
 165         const struct labpc_boardinfo *board = dev->board_ptr;
 166         struct labpc_private *devpriv = dev->private;
 167
 168         if (!board->is_labpc1200)
 169                 return;
 170
 171         /* reference inputs to ground or common? */
 172         if (aref != AREF_GROUND)
 173                 devpriv->cmd6 |= CMD6_NRSE;
 174         else
 175                 devpriv->cmd6 &= ~CMD6_NRSE;
 176
 177         /* bipolar or unipolar range? */
 178         if (comedi_range_is_unipolar(s, range))
 179                 devpriv->cmd6 |= CMD6_ADCUNI;
 180         else
 181                 devpriv->cmd6 &= ~CMD6_ADCUNI;
 182
 183         /*  interrupt on fifo half full? */
 184         if (xfer == fifo_half_full_transfer)
 185                 devpriv->cmd6 |= CMD6_HFINTEN;
 186         else
 187                 devpriv->cmd6 &= ~CMD6_HFINTEN;
 188
 189         /* enable interrupt on counter a1 terminal count? */
 190         if (ena_intr)
 191                 devpriv->cmd6 |= CMD6_DQINTEN;
 192         else
 193                 devpriv->cmd6 &= ~CMD6_DQINTEN;
 194
 195         /* are we scanning up or down through channels? */
 196         if (mode == MODE_MULT_CHAN_UP)
 197                 devpriv->cmd6 |= CMD6_SCANUP;
 198         else
 199                 devpriv->cmd6 &= ~CMD6_SCANUP;
 200
 201         devpriv->write_byte(dev, devpriv->cmd6, CMD6_REG);
 202 }
 203
 204 static unsigned int labpc_read_adc_fifo(struct comedi_device *dev)
 205 {
 206         struct labpc_private *devpriv = dev->private;
 207         unsigned int lsb = devpriv->read_byte(dev, ADC_FIFO_REG);
 208         unsigned int msb = devpriv->read_byte(dev, ADC_FIFO_REG);
 209
 210         return (msb << 8) | lsb;
 211 }
 212
 213 static void labpc_clear_adc_fifo(struct comedi_device *dev)
 214 {
 215         struct labpc_private *devpriv = dev->private;
 216
 217         devpriv->write_byte(dev, 0x1, ADC_FIFO_CLEAR_REG);
 218         labpc_read_adc_fifo(dev);
 219 }
 220
 221 static int labpc_ai_eoc(struct comedi_device *dev,
 222                         struct comedi_subdevice *s,
 223                         struct comedi_insn *insn,
 224                         unsigned long context)
 225 {
 226         struct labpc_private *devpriv = dev->private;
 227
 228         devpriv->stat1 = devpriv->read_byte(dev, STAT1_REG);
 229         if (devpriv->stat1 & STAT1_DAVAIL)
 230                 return 0;
 231         return -EBUSY;
 232 }
 233
 234 static int labpc_ai_insn_read(struct comedi_device *dev,
 235                               struct comedi_subdevice *s,
 236                               struct comedi_insn *insn,
 237                               unsigned int *data)
 238 {
 239         struct labpc_private *devpriv = dev->private;
 240         unsigned int chan = CR_CHAN(insn->chanspec);
 241         unsigned int range = CR_RANGE(insn->chanspec);
 242         unsigned int aref = CR_AREF(insn->chanspec);
 243         int ret;
 244         int i;
 245
 246         /* disable timed conversions, interrupt generation and dma */
 247         labpc_cancel(dev, s);
 248
 249         labpc_ai_set_chan_and_gain(dev, MODE_SINGLE_CHAN, chan, range, aref);
 250
 251         labpc_setup_cmd6_reg(dev, s, MODE_SINGLE_CHAN, fifo_not_empty_transfer,
 252                              range, aref, false);
 253
 254         /* setup cmd4 register */
 255         devpriv->cmd4 = 0;
 256         devpriv->cmd4 |= CMD4_ECLKRCV;
 257         /* single-ended/differential */
 258         if (aref == AREF_DIFF)
 259                 devpriv->cmd4 |= CMD4_SEDIFF;
 260         devpriv->write_byte(dev, devpriv->cmd4, CMD4_REG);
 261
 262         /* initialize pacer counter to prevent any problems */
 263         comedi_8254_set_mode(devpriv->counter, 0, I8254_MODE2 | I8254_BINARY);
 264
 265         labpc_clear_adc_fifo(dev);
 266
 267         for (i = 0; i < insn->n; i++) {
 268                 /* trigger conversion */
 269                 devpriv->write_byte(dev, 0x1, ADC_START_CONVERT_REG);
 270
 271                 ret = comedi_timeout(dev, s, insn, labpc_ai_eoc, 0);
 272                 if (ret)
 273                         return ret;
 274
 275                 data[i] = labpc_read_adc_fifo(dev);
 276         }
 277
 278         return insn->n;
 279 }
 280
 281 static bool labpc_use_continuous_mode(const struct comedi_cmd *cmd,
 282                                       enum scan_mode mode)
 283 {
 284         if (mode == MODE_SINGLE_CHAN || cmd->scan_begin_src == TRIG_FOLLOW)
 285                 return true;
 286
 287         return false;
 288 }
 289
 290 static unsigned int labpc_ai_convert_period(const struct comedi_cmd *cmd,
 291                                             enum scan_mode mode)
 292 {
 293         if (cmd->convert_src != TRIG_TIMER)
 294                 return 0;
 295
 296         if (mode == MODE_SINGLE_CHAN && cmd->scan_begin_src == TRIG_TIMER)
 297                 return cmd->scan_begin_arg;
 298
 299         return cmd->convert_arg;
 300 }
 301
 302 static void labpc_set_ai_convert_period(struct comedi_cmd *cmd,
 303                                         enum scan_mode mode, unsigned int ns)
 304 {
 305         if (cmd->convert_src != TRIG_TIMER)
 306                 return;
 307
 308         if (mode == MODE_SINGLE_CHAN &&
 309             cmd->scan_begin_src == TRIG_TIMER) {
 310                 cmd->scan_begin_arg = ns;
 311                 if (cmd->convert_arg > cmd->scan_begin_arg)
 312                         cmd->convert_arg = cmd->scan_begin_arg;
 313         } else {
 314                 cmd->convert_arg = ns;
 315         }
 316 }
 317
 318 static unsigned int labpc_ai_scan_period(const struct comedi_cmd *cmd,
 319                                          enum scan_mode mode)
 320 {
 321         if (cmd->scan_begin_src != TRIG_TIMER)
 322                 return 0;
 323
 324         if (mode == MODE_SINGLE_CHAN && cmd->convert_src == TRIG_TIMER)
 325                 return 0;
 326
 327         return cmd->scan_begin_arg;
 328 }
 329
 330 static void labpc_set_ai_scan_period(struct comedi_cmd *cmd,
 331                                      enum scan_mode mode, unsigned int ns)
 332 {
 333         if (cmd->scan_begin_src != TRIG_TIMER)
 334                 return;
 335
 336         if (mode == MODE_SINGLE_CHAN && cmd->convert_src == TRIG_TIMER)
 337                 return;
 338
 339         cmd->scan_begin_arg = ns;
 340 }
 341
 342 /* figures out what counter values to use based on command */
 343 static void labpc_adc_timing(struct comedi_device *dev, struct comedi_cmd *cmd,
 344                              enum scan_mode mode)
 345 {
 346         struct comedi_8254 *pacer = dev->pacer;
 347         unsigned int convert_period = labpc_ai_convert_period(cmd, mode);
 348         unsigned int scan_period = labpc_ai_scan_period(cmd, mode);
 349         unsigned int base_period;
 350
 351         /*
 352          * If both convert and scan triggers are TRIG_TIMER, then they
 353          * both rely on counter b0. If only one TRIG_TIMER is used, we
 354          * can use the generic cascaded timing functions.
 355          */
 356         if (convert_period && scan_period) {
 357                 /*
 358                  * pick the lowest divisor value we can (for maximum input
 359                  * clock speed on convert and scan counters)
 360                  */
 361                 pacer->next_div1 = (scan_period - 1) /
 362                                    (pacer->osc_base * I8254_MAX_COUNT) + 1;
 363
 364                 comedi_check_trigger_arg_min(&pacer->next_div1, 2);
 365                 comedi_check_trigger_arg_max(&pacer->next_div1,
 366                                              I8254_MAX_COUNT);
 367
 368                 base_period = pacer->osc_base * pacer->next_div1;
 369
 370                 /*  set a0 for conversion frequency and b1 for scan frequency */
 371                 switch (cmd->flags & CMDF_ROUND_MASK) {
 372                 default:
 373                 case CMDF_ROUND_NEAREST:
 374                         pacer->next_div = DIV_ROUND_CLOSEST(convert_period,
 375                                                             base_period);
 376                         pacer->next_div2 = DIV_ROUND_CLOSEST(scan_period,
 377                                                              base_period);
 378                         break;
 379                 case CMDF_ROUND_UP:
 380                         pacer->next_div = DIV_ROUND_UP(convert_period,
 381                                                        base_period);
 382                         pacer->next_div2 = DIV_ROUND_UP(scan_period,
 383                                                         base_period);
 384                         break;
 385                 case CMDF_ROUND_DOWN:
 386                         pacer->next_div = convert_period / base_period;
 387                         pacer->next_div2 = scan_period / base_period;
 388                         break;
 389                 }
 390                 /*  make sure a0 and b1 values are acceptable */
 391                 comedi_check_trigger_arg_min(&pacer->next_div, 2);
 392                 comedi_check_trigger_arg_max(&pacer->next_div, I8254_MAX_COUNT);
 393                 comedi_check_trigger_arg_min(&pacer->next_div2, 2);
 394                 comedi_check_trigger_arg_max(&pacer->next_div2,
 395                                              I8254_MAX_COUNT);
 396
 397                 /*  write corrected timings to command */
 398                 labpc_set_ai_convert_period(cmd, mode,
 399                                             base_period * pacer->next_div);
 400                 labpc_set_ai_scan_period(cmd, mode,
 401                                          base_period * pacer->next_div2);
 402         } else if (scan_period) {
 403                 /*
 404                  * calculate cascaded counter values
 405                  * that give desired scan timing
 406                  * (pacer->next_div2 / pacer->next_div1)
 407                  */
 408                 comedi_8254_cascade_ns_to_timer(pacer, &scan_period,
 409                                                 cmd->flags);
 410                 labpc_set_ai_scan_period(cmd, mode, scan_period);
 411         } else if (convert_period) {
 412                 /*
 413                  * calculate cascaded counter values
 414                  * that give desired conversion timing
 415                  * (pacer->next_div / pacer->next_div1)
 416                  */
 417                 comedi_8254_cascade_ns_to_timer(pacer, &convert_period,
 418                                                 cmd->flags);
 419                 /* transfer div2 value so correct timer gets updated */
 420                 pacer->next_div = pacer->next_div2;
 421                 labpc_set_ai_convert_period(cmd, mode, convert_period);
 422         }
 423 }
 424
 425 static enum scan_mode labpc_ai_scan_mode(const struct comedi_cmd *cmd)
 426 {
 427         unsigned int chan0;
 428         unsigned int chan1;
 429
 430         if (cmd->chanlist_len == 1)
 431                 return MODE_SINGLE_CHAN;
 432
 433         /* chanlist may be NULL during cmdtest */
 434         if (!cmd->chanlist)
 435                 return MODE_MULT_CHAN_UP;
 436
 437         chan0 = CR_CHAN(cmd->chanlist[0]);
 438         chan1 = CR_CHAN(cmd->chanlist[1]);
 439
 440         if (chan0 < chan1)
 441                 return MODE_MULT_CHAN_UP;
 442
 443         if (chan0 > chan1)
 444                 return MODE_MULT_CHAN_DOWN;
 445
 446         return MODE_SINGLE_CHAN_INTERVAL;
 447 }
 448
 449 static int labpc_ai_check_chanlist(struct comedi_device *dev,
 450                                    struct comedi_subdevice *s,
 451                                    struct comedi_cmd *cmd)
 452 {
 453         enum scan_mode mode = labpc_ai_scan_mode(cmd);
 454         unsigned int chan0 = CR_CHAN(cmd->chanlist[0]);
 455         unsigned int range0 = CR_RANGE(cmd->chanlist[0]);
 456         unsigned int aref0 = CR_AREF(cmd->chanlist[0]);
 457         int i;
 458
 459         for (i = 0; i < cmd->chanlist_len; i++) {
 460                 unsigned int chan = CR_CHAN(cmd->chanlist[i]);
 461                 unsigned int range = CR_RANGE(cmd->chanlist[i]);
 462                 unsigned int aref = CR_AREF(cmd->chanlist[i]);
 463
 464                 switch (mode) {
 465                 case MODE_SINGLE_CHAN:
 466                         break;
 467                 case MODE_SINGLE_CHAN_INTERVAL:
 468                         if (chan != chan0) {
 469                                 dev_dbg(dev->class_dev,
 470                                         "channel scanning order specified in chanlist is not supported by hardware\n");
 471                                 return -EINVAL;
 472                         }
 473                         break;
 474                 case MODE_MULT_CHAN_UP:
 475                         if (chan != i) {
 476                                 dev_dbg(dev->class_dev,
 477                                         "channel scanning order specified in chanlist is not supported by hardware\n");
 478                                 return -EINVAL;
 479                         }
 480                         break;
 481                 case MODE_MULT_CHAN_DOWN:
 482                         if (chan != (cmd->chanlist_len - i - 1)) {
 483                                 dev_dbg(dev->class_dev,
 484                                         "channel scanning order specified in chanlist is not supported by hardware\n");
 485                                 return -EINVAL;
 486                         }
 487                         break;
 488                 }
 489
 490                 if (range != range0) {
 491                         dev_dbg(dev->class_dev,
 492                                 "entries in chanlist must all have the same range\n");
 493                         return -EINVAL;
 494                 }
 495
 496                 if (aref != aref0) {
 497                         dev_dbg(dev->class_dev,
 498                                 "entries in chanlist must all have the same reference\n");
 499                         return -EINVAL;
 500                 }
 501         }
 502
 503         return 0;
 504 }
 505
 506 static int labpc_ai_cmdtest(struct comedi_device *dev,
 507                             struct comedi_subdevice *s, struct comedi_cmd *cmd)
 508 {
 509         const struct labpc_boardinfo *board = dev->board_ptr;
 510         int err = 0;
 511         int tmp, tmp2;
 512         unsigned int stop_mask;
 513         enum scan_mode mode;
 514
 515         /* Step 1 : check if triggers are trivially valid */
 516
 517         err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
 518         err |= comedi_check_trigger_src(&cmd->scan_begin_src,
 519                                         TRIG_TIMER | TRIG_FOLLOW | TRIG_EXT);
 520         err |= comedi_check_trigger_src(&cmd->convert_src,
 521                                         TRIG_TIMER | TRIG_EXT);
 522         err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 523
 524         stop_mask = TRIG_COUNT | TRIG_NONE;
 525         if (board->is_labpc1200)
 526                 stop_mask |= TRIG_EXT;
 527         err |= comedi_check_trigger_src(&cmd->stop_src, stop_mask);
 528
 529         if (err)
 530                 return 1;
 531
 532         /* Step 2a : make sure trigger sources are unique */
 533
 534         err |= comedi_check_trigger_is_unique(cmd->start_src);
 535         err |= comedi_check_trigger_is_unique(cmd->scan_begin_src);
 536         err |= comedi_check_trigger_is_unique(cmd->convert_src);
 537         err |= comedi_check_trigger_is_unique(cmd->stop_src);
 538
 539         /* Step 2b : and mutually compatible */
 540
 541         /* can't have external stop and start triggers at once */
 542         if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT)
 543                 err++;
 544
 545         if (err)
 546                 return 2;
 547
 548         /* Step 3: check if arguments are trivially valid */
 549
 550         switch (cmd->start_src) {
 551         case TRIG_NOW:
 552                 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
 553                 break;
 554         case TRIG_EXT:
 555                 /* start_arg value is ignored */
 556                 break;
 557         }
 558
 559         if (!cmd->chanlist_len)
 560                 err |= -EINVAL;
 561         err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
 562                                            cmd->chanlist_len);
 563
 564         if (cmd->convert_src == TRIG_TIMER) {
 565                 err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
 566                                                     board->ai_speed);
 567         }
 568
 569         /* make sure scan timing is not too fast */
 570         if (cmd->scan_begin_src == TRIG_TIMER) {
 571                 if (cmd->convert_src == TRIG_TIMER) {
 572                         err |= comedi_check_trigger_arg_min(&cmd->
 573                                                             scan_begin_arg,
 574                                                             cmd->convert_arg *
 575                                                             cmd->chanlist_len);
 576                 }
 577                 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
 578                                                     board->ai_speed *
 579                                                     cmd->chanlist_len);
 580         }
 581
 582         switch (cmd->stop_src) {
 583         case TRIG_COUNT:
 584                 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
 585                 break;
 586         case TRIG_NONE:
 587                 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
 588                 break;
 589                 /*
 590                  * TRIG_EXT doesn't care since it doesn't
 591                  * trigger off a numbered channel
 592                  */
 593         default:
 594                 break;
 595         }
 596
 597         if (err)
 598                 return 3;
 599
 600         /* step 4: fix up any arguments */
 601
 602         tmp = cmd->convert_arg;
 603         tmp2 = cmd->scan_begin_arg;
 604         mode = labpc_ai_scan_mode(cmd);
 605         labpc_adc_timing(dev, cmd, mode);
 606         if (tmp != cmd->convert_arg || tmp2 != cmd->scan_begin_arg)
 607                 err++;
 608
 609         if (err)
 610                 return 4;
 611
 612         /* Step 5: check channel list if it exists */
 613         if (cmd->chanlist && cmd->chanlist_len > 0)
 614                 err |= labpc_ai_check_chanlist(dev, s, cmd);
 615
 616         if (err)
 617                 return 5;
 618
 619         return 0;
 620 }
 621
 622 static int labpc_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 623 {
 624         const struct labpc_boardinfo *board = dev->board_ptr;
 625         struct labpc_private *devpriv = dev->private;
 626         struct comedi_async *async = s->async;
 627         struct comedi_cmd *cmd = &async->cmd;
 628         enum scan_mode mode = labpc_ai_scan_mode(cmd);
 629         unsigned int chanspec = (mode == MODE_MULT_CHAN_UP) ?
 630                                 cmd->chanlist[cmd->chanlist_len - 1] :
 631                                 cmd->chanlist[0];
 632         unsigned int chan = CR_CHAN(chanspec);
 633         unsigned int range = CR_RANGE(chanspec);
 634         unsigned int aref = CR_AREF(chanspec);
 635         enum transfer_type xfer;
 636         unsigned long flags;
 637
 638         /* make sure board is disabled before setting up acquisition */
 639         labpc_cancel(dev, s);
 640
 641         /*  initialize software conversion count */
 642         if (cmd->stop_src == TRIG_COUNT)
 643                 devpriv->count = cmd->stop_arg * cmd->chanlist_len;
 644
 645         /*  setup hardware conversion counter */
 646         if (cmd->stop_src == TRIG_EXT) {
 647                 /*
 648                  * load counter a1 with count of 3
 649                  * (pc+ manual says this is minimum allowed) using mode 0
 650                  */
 651                 comedi_8254_load(devpriv->counter, 1,
 652                                  3, I8254_MODE0 | I8254_BINARY);
 653         } else  {
 654                 /* just put counter a1 in mode 0 to set its output low */
 655                 comedi_8254_set_mode(devpriv->counter, 1,
 656                                      I8254_MODE0 | I8254_BINARY);
 657         }
 658
 659         /* figure out what method we will use to transfer data */
 660         if (devpriv->dma &&
 661             (cmd->flags & (CMDF_WAKE_EOS | CMDF_PRIORITY)) == 0) {
 662                 /*
 663                  * dma unsafe at RT priority,
 664                  * and too much setup time for CMDF_WAKE_EOS
 665                  */
 666                 xfer = isa_dma_transfer;
 667         } else if (board->is_labpc1200 &&
 668                    (cmd->flags & CMDF_WAKE_EOS) == 0 &&
 669                    (cmd->stop_src != TRIG_COUNT || devpriv->count > 256)) {
 670                 /*
 671                  * pc-plus has no fifo-half full interrupt
 672                  * wake-end-of-scan should interrupt on fifo not empty
 673                  * make sure we are taking more than just a few points
 674                  */
 675                 xfer = fifo_half_full_transfer;
 676         } else {
 677                 xfer = fifo_not_empty_transfer;
 678         }
 679         devpriv->current_transfer = xfer;
 680
 681         labpc_ai_set_chan_and_gain(dev, mode, chan, range, aref);
 682
 683         labpc_setup_cmd6_reg(dev, s, mode, xfer, range, aref,
 684                              (cmd->stop_src == TRIG_EXT));
 685
 686         /* manual says to set scan enable bit on second pass */
 687         if (mode == MODE_MULT_CHAN_UP || mode == MODE_MULT_CHAN_DOWN) {
 688                 devpriv->cmd1 |= CMD1_SCANEN;
 689                 /*
 690                  * Need a brief delay before enabling scan, or scan
 691                  * list will get screwed when you switch between
 692                  * scan up to scan down mode - dunno why.
 693                  */
 694                 udelay(1);
 695                 devpriv->write_byte(dev, devpriv->cmd1, CMD1_REG);
 696         }
 697
 698         devpriv->write_byte(dev, cmd->chanlist_len, INTERVAL_COUNT_REG);
 699         /*  load count */
 700         devpriv->write_byte(dev, 0x1, INTERVAL_STROBE_REG);
 701
 702         if (cmd->convert_src == TRIG_TIMER ||
 703             cmd->scan_begin_src == TRIG_TIMER) {
 704                 struct comedi_8254 *pacer = dev->pacer;
 705                 struct comedi_8254 *counter = devpriv->counter;
 706
 707                 comedi_8254_update_divisors(pacer);
 708
 709                 /* set up pacing */
 710                 comedi_8254_load(pacer, 0, pacer->divisor1,
 711                                  I8254_MODE3 | I8254_BINARY);
 712
 713                 /* set up conversion pacing */
 714                 comedi_8254_set_mode(counter, 0, I8254_MODE2 | I8254_BINARY);
 715                 if (labpc_ai_convert_period(cmd, mode))
 716                         comedi_8254_write(counter, 0, pacer->divisor);
 717
 718                 /* set up scan pacing */
 719                 if (labpc_ai_scan_period(cmd, mode))
 720                         comedi_8254_load(pacer, 1, pacer->divisor2,
 721                                          I8254_MODE2 | I8254_BINARY);
 722         }
 723
 724         labpc_clear_adc_fifo(dev);
 725
 726         if (xfer == isa_dma_transfer)
 727                 labpc_setup_dma(dev, s);
 728
 729         /*  enable error interrupts */
 730         devpriv->cmd3 |= CMD3_ERRINTEN;
 731         /*  enable fifo not empty interrupt? */
 732         if (xfer == fifo_not_empty_transfer)
 733                 devpriv->cmd3 |= CMD3_FIFOINTEN;
 734         devpriv->write_byte(dev, devpriv->cmd3, CMD3_REG);
 735
 736         /*  setup any external triggering/pacing (cmd4 register) */
 737         devpriv->cmd4 = 0;
 738         if (cmd->convert_src != TRIG_EXT)
 739                 devpriv->cmd4 |= CMD4_ECLKRCV;
 740         /*
 741          * XXX should discard first scan when using interval scanning
 742          * since manual says it is not synced with scan clock.
 743          */
 744         if (!labpc_use_continuous_mode(cmd, mode)) {
 745                 devpriv->cmd4 |= CMD4_INTSCAN;
 746                 if (cmd->scan_begin_src == TRIG_EXT)
 747                         devpriv->cmd4 |= CMD4_EOIRCV;
 748         }
 749         /*  single-ended/differential */
 750         if (aref == AREF_DIFF)
 751                 devpriv->cmd4 |= CMD4_SEDIFF;
 752         devpriv->write_byte(dev, devpriv->cmd4, CMD4_REG);
 753
 754         /*  startup acquisition */
 755
 756         spin_lock_irqsave(&dev->spinlock, flags);
 757
 758         /* use 2 cascaded counters for pacing */
 759         devpriv->cmd2 |= CMD2_TBSEL;
 760
 761         devpriv->cmd2 &= ~(CMD2_SWTRIG | CMD2_HWTRIG | CMD2_PRETRIG);
 762         if (cmd->start_src == TRIG_EXT)
 763                 devpriv->cmd2 |= CMD2_HWTRIG;
 764         else
 765                 devpriv->cmd2 |= CMD2_SWTRIG;
 766         if (cmd->stop_src == TRIG_EXT)
 767                 devpriv->cmd2 |= (CMD2_HWTRIG | CMD2_PRETRIG);
 768
 769         devpriv->write_byte(dev, devpriv->cmd2, CMD2_REG);
 770
 771         spin_unlock_irqrestore(&dev->spinlock, flags);
 772
 773         return 0;
 774 }
 775
 776 /* read all available samples from ai fifo */
 777 static int labpc_drain_fifo(struct comedi_device *dev)
 778 {
 779         struct labpc_private *devpriv = dev->private;
 780         struct comedi_async *async = dev->read_subdev->async;
 781         struct comedi_cmd *cmd = &async->cmd;
 782         unsigned short data;
 783         const int timeout = 10000;
 784         unsigned int i;
 785
 786         devpriv->stat1 = devpriv->read_byte(dev, STAT1_REG);
 787
 788         for (i = 0; (devpriv->stat1 & STAT1_DAVAIL) && i < timeout;
 789              i++) {
 790                 /*  quit if we have all the data we want */
 791                 if (cmd->stop_src == TRIG_COUNT) {
 792                         if (devpriv->count == 0)
 793                                 break;
 794                         devpriv->count--;
 795                 }
 796                 data = labpc_read_adc_fifo(dev);
 797                 comedi_buf_write_samples(dev->read_subdev, &data, 1);
 798                 devpriv->stat1 = devpriv->read_byte(dev, STAT1_REG);
 799         }
 800         if (i == timeout) {
 801                 dev_err(dev->class_dev, "ai timeout, fifo never empties\n");
 802                 async->events |= COMEDI_CB_ERROR;
 803                 return -1;
 804         }
 805
 806         return 0;
 807 }
 808
 809 /*
 810  * Makes sure all data acquired by board is transferred to comedi (used
 811  * when acquisition is terminated by stop_src == TRIG_EXT).
 812  */
 813 static void labpc_drain_dregs(struct comedi_device *dev)
 814 {
 815         struct labpc_private *devpriv = dev->private;
 816
 817         if (devpriv->current_transfer == isa_dma_transfer)
 818                 labpc_drain_dma(dev);
 819
 820         labpc_drain_fifo(dev);
 821 }
 822
 823 /* interrupt service routine */
 824 static irqreturn_t labpc_interrupt(int irq, void *d)
 825 {
 826         struct comedi_device *dev = d;
 827         const struct labpc_boardinfo *board = dev->board_ptr;
 828         struct labpc_private *devpriv = dev->private;
 829         struct comedi_subdevice *s = dev->read_subdev;
 830         struct comedi_async *async;
 831         struct comedi_cmd *cmd;
 832
 833         if (!dev->attached) {
 834                 dev_err(dev->class_dev, "premature interrupt\n");
 835                 return IRQ_HANDLED;
 836         }
 837
 838         async = s->async;
 839         cmd = &async->cmd;
 840
 841         /* read board status */
 842         devpriv->stat1 = devpriv->read_byte(dev, STAT1_REG);
 843         if (board->is_labpc1200)
 844                 devpriv->stat2 = devpriv->read_byte(dev, STAT2_REG);
 845
 846         if ((devpriv->stat1 & (STAT1_GATA0 | STAT1_CNTINT | STAT1_OVERFLOW |
 847                                STAT1_OVERRUN | STAT1_DAVAIL)) == 0 &&
 848             (devpriv->stat2 & STAT2_OUTA1) == 0 &&
 849             (devpriv->stat2 & STAT2_FIFONHF)) {
 850                 return IRQ_NONE;
 851         }
 852
 853         if (devpriv->stat1 & STAT1_OVERRUN) {
 854                 /* clear error interrupt */
 855                 devpriv->write_byte(dev, 0x1, ADC_FIFO_CLEAR_REG);
 856                 async->events |= COMEDI_CB_ERROR;
 857                 comedi_handle_events(dev, s);
 858                 dev_err(dev->class_dev, "overrun\n");
 859                 return IRQ_HANDLED;
 860         }
 861
 862         if (devpriv->current_transfer == isa_dma_transfer)
 863                 labpc_handle_dma_status(dev);
 864         else
 865                 labpc_drain_fifo(dev);
 866
 867         if (devpriv->stat1 & STAT1_CNTINT) {
 868                 dev_err(dev->class_dev, "handled timer interrupt?\n");
 869                 /*  clear it */
 870                 devpriv->write_byte(dev, 0x1, TIMER_CLEAR_REG);
 871         }
 872
 873         if (devpriv->stat1 & STAT1_OVERFLOW) {
 874                 /*  clear error interrupt */
 875                 devpriv->write_byte(dev, 0x1, ADC_FIFO_CLEAR_REG);
 876                 async->events |= COMEDI_CB_ERROR;
 877                 comedi_handle_events(dev, s);
 878                 dev_err(dev->class_dev, "overflow\n");
 879                 return IRQ_HANDLED;
 880         }
 881         /*  handle external stop trigger */
 882         if (cmd->stop_src == TRIG_EXT) {
 883                 if (devpriv->stat2 & STAT2_OUTA1) {
 884                         labpc_drain_dregs(dev);
 885                         async->events |= COMEDI_CB_EOA;
 886                 }
 887         }
 888
 889         /* TRIG_COUNT end of acquisition */
 890         if (cmd->stop_src == TRIG_COUNT) {
 891                 if (devpriv->count == 0)
 892                         async->events |= COMEDI_CB_EOA;
 893         }
 894
 895         comedi_handle_events(dev, s);
 896         return IRQ_HANDLED;
 897 }
 898
 899 static void labpc_ao_write(struct comedi_device *dev,
 900                            struct comedi_subdevice *s,
 901                            unsigned int chan, unsigned int val)
 902 {
 903         struct labpc_private *devpriv = dev->private;
 904
 905         devpriv->write_byte(dev, val & 0xff, DAC_LSB_REG(chan));
 906         devpriv->write_byte(dev, (val >> 8) & 0xff, DAC_MSB_REG(chan));
 907
 908         s->readback[chan] = val;
 909 }
 910
 911 static int labpc_ao_insn_write(struct comedi_device *dev,
 912                                struct comedi_subdevice *s,
 913                                struct comedi_insn *insn,
 914                                unsigned int *data)
 915 {
 916         const struct labpc_boardinfo *board = dev->board_ptr;
 917         struct labpc_private *devpriv = dev->private;
 918         int channel, range;
 919         unsigned long flags;
 920
 921         channel = CR_CHAN(insn->chanspec);
 922
 923         /*
 924          * Turn off pacing of analog output channel.
 925          * NOTE: hardware bug in daqcard-1200 means pacing cannot
 926          * be independently enabled/disabled for its the two channels.
 927          */
 928         spin_lock_irqsave(&dev->spinlock, flags);
 929         devpriv->cmd2 &= ~CMD2_LDAC(channel);
 930         devpriv->write_byte(dev, devpriv->cmd2, CMD2_REG);
 931         spin_unlock_irqrestore(&dev->spinlock, flags);
 932
 933         /* set range */
 934         if (board->is_labpc1200) {
 935                 range = CR_RANGE(insn->chanspec);
 936                 if (comedi_range_is_unipolar(s, range))
 937                         devpriv->cmd6 |= CMD6_DACUNI(channel);
 938                 else
 939                         devpriv->cmd6 &= ~CMD6_DACUNI(channel);
 940                 /*  write to register */
 941                 devpriv->write_byte(dev, devpriv->cmd6, CMD6_REG);
 942         }
 943         /* send data */
 944         labpc_ao_write(dev, s, channel, data[0]);
 945
 946         return 1;
 947 }
 948
 949 /* lowlevel write to eeprom/dac */
 950 static void labpc_serial_out(struct comedi_device *dev, unsigned int value,
 951                              unsigned int value_width)
 952 {
 953         struct labpc_private *devpriv = dev->private;
 954         int i;
 955
 956         for (i = 1; i <= value_width; i++) {
 957                 /*  clear serial clock */
 958                 devpriv->cmd5 &= ~CMD5_SCLK;
 959                 /*  send bits most significant bit first */
 960                 if (value & (1 << (value_width - i)))
 961                         devpriv->cmd5 |= CMD5_SDATA;
 962                 else
 963                         devpriv->cmd5 &= ~CMD5_SDATA;
 964                 udelay(1);
 965                 devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
 966                 /*  set clock to load bit */
 967                 devpriv->cmd5 |= CMD5_SCLK;
 968                 udelay(1);
 969                 devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
 970         }
 971 }
 972
 973 /* lowlevel read from eeprom */
 974 static unsigned int labpc_serial_in(struct comedi_device *dev)
 975 {
 976         struct labpc_private *devpriv = dev->private;
 977         unsigned int value = 0;
 978         int i;
 979         const int value_width = 8;      /*  number of bits wide values are */
 980
 981         for (i = 1; i <= value_width; i++) {
 982                 /*  set serial clock */
 983                 devpriv->cmd5 |= CMD5_SCLK;
 984                 udelay(1);
 985                 devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
 986                 /*  clear clock bit */
 987                 devpriv->cmd5 &= ~CMD5_SCLK;
 988                 udelay(1);
 989                 devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
 990                 /*  read bits most significant bit first */
 991                 udelay(1);
 992                 devpriv->stat2 = devpriv->read_byte(dev, STAT2_REG);
 993                 if (devpriv->stat2 & STAT2_PROMOUT)
 994                         value |= 1 << (value_width - i);
 995         }
 996
 997         return value;
 998 }
 999
1000 static unsigned int labpc_eeprom_read(struct comedi_device *dev,
1001                                       unsigned int address)
1002 {
1003         struct labpc_private *devpriv = dev->private;
1004         unsigned int value;
1005         /*  bits to tell eeprom to expect a read */
1006         const int read_instruction = 0x3;
1007         /*  8 bit write lengths to eeprom */
1008         const int write_length = 8;
1009
1010         /*  enable read/write to eeprom */
1011         devpriv->cmd5 &= ~CMD5_EEPROMCS;
1012         udelay(1);
1013         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1014         devpriv->cmd5 |= (CMD5_EEPROMCS | CMD5_WRTPRT);
1015         udelay(1);
1016         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1017
1018         /*  send read instruction */
1019         labpc_serial_out(dev, read_instruction, write_length);
1020         /*  send 8 bit address to read from */
1021         labpc_serial_out(dev, address, write_length);
1022         /*  read result */
1023         value = labpc_serial_in(dev);
1024
1025         /*  disable read/write to eeprom */
1026         devpriv->cmd5 &= ~(CMD5_EEPROMCS | CMD5_WRTPRT);
1027         udelay(1);
1028         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1029
1030         return value;
1031 }
1032
1033 static unsigned int labpc_eeprom_read_status(struct comedi_device *dev)
1034 {
1035         struct labpc_private *devpriv = dev->private;
1036         unsigned int value;
1037         const int read_status_instruction = 0x5;
1038         const int write_length = 8;     /*  8 bit write lengths to eeprom */
1039
1040         /*  enable read/write to eeprom */
1041         devpriv->cmd5 &= ~CMD5_EEPROMCS;
1042         udelay(1);
1043         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1044         devpriv->cmd5 |= (CMD5_EEPROMCS | CMD5_WRTPRT);
1045         udelay(1);
1046         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1047
1048         /*  send read status instruction */
1049         labpc_serial_out(dev, read_status_instruction, write_length);
1050         /*  read result */
1051         value = labpc_serial_in(dev);
1052
1053         /*  disable read/write to eeprom */
1054         devpriv->cmd5 &= ~(CMD5_EEPROMCS | CMD5_WRTPRT);
1055         udelay(1);
1056         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1057
1058         return value;
1059 }
1060
1061 static void labpc_eeprom_write(struct comedi_device *dev,
1062                                unsigned int address, unsigned int value)
1063 {
1064         struct labpc_private *devpriv = dev->private;
1065         const int write_enable_instruction = 0x6;
1066         const int write_instruction = 0x2;
1067         const int write_length = 8;     /*  8 bit write lengths to eeprom */
1068
1069         /*  enable read/write to eeprom */
1070         devpriv->cmd5 &= ~CMD5_EEPROMCS;
1071         udelay(1);
1072         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1073         devpriv->cmd5 |= (CMD5_EEPROMCS | CMD5_WRTPRT);
1074         udelay(1);
1075         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1076
1077         /*  send write_enable instruction */
1078         labpc_serial_out(dev, write_enable_instruction, write_length);
1079         devpriv->cmd5 &= ~CMD5_EEPROMCS;
1080         udelay(1);
1081         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1082
1083         /*  send write instruction */
1084         devpriv->cmd5 |= CMD5_EEPROMCS;
1085         udelay(1);
1086         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1087         labpc_serial_out(dev, write_instruction, write_length);
1088         /*  send 8 bit address to write to */
1089         labpc_serial_out(dev, address, write_length);
1090         /*  write value */
1091         labpc_serial_out(dev, value, write_length);
1092         devpriv->cmd5 &= ~CMD5_EEPROMCS;
1093         udelay(1);
1094         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1095
1096         /*  disable read/write to eeprom */
1097         devpriv->cmd5 &= ~(CMD5_EEPROMCS | CMD5_WRTPRT);
1098         udelay(1);
1099         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1100 }
1101
1102 /* writes to 8 bit calibration dacs */
1103 static void write_caldac(struct comedi_device *dev, unsigned int channel,
1104                          unsigned int value)
1105 {
1106         struct labpc_private *devpriv = dev->private;
1107
1108         /*  clear caldac load bit and make sure we don't write to eeprom */
1109         devpriv->cmd5 &= ~(CMD5_CALDACLD | CMD5_EEPROMCS | CMD5_WRTPRT);
1110         udelay(1);
1111         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1112
1113         /*  write 4 bit channel */
1114         labpc_serial_out(dev, channel, 4);
1115         /*  write 8 bit caldac value */
1116         labpc_serial_out(dev, value, 8);
1117
1118         /*  set and clear caldac bit to load caldac value */
1119         devpriv->cmd5 |= CMD5_CALDACLD;
1120         udelay(1);
1121         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1122         devpriv->cmd5 &= ~CMD5_CALDACLD;
1123         udelay(1);
1124         devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1125 }
1126
1127 static int labpc_calib_insn_write(struct comedi_device *dev,
1128                                   struct comedi_subdevice *s,
1129                                   struct comedi_insn *insn,
1130                                   unsigned int *data)
1131 {
1132         unsigned int chan = CR_CHAN(insn->chanspec);
1133
1134         /*
1135          * Only write the last data value to the caldac. Preceding
1136          * data would be overwritten anyway.
1137          */
1138         if (insn->n > 0) {
1139                 unsigned int val = data[insn->n - 1];
1140
1141                 if (s->readback[chan] != val) {
1142                         write_caldac(dev, chan, val);
1143                         s->readback[chan] = val;
1144                 }
1145         }
1146
1147         return insn->n;
1148 }
1149
1150 static int labpc_eeprom_ready(struct comedi_device *dev,
1151                               struct comedi_subdevice *s,
1152                               struct comedi_insn *insn,
1153                               unsigned long context)
1154 {
1155         unsigned int status;
1156
1157         /* make sure there isn't already a write in progress */
1158         status = labpc_eeprom_read_status(dev);
1159         if ((status & 0x1) == 0)
1160                 return 0;
1161         return -EBUSY;
1162 }
1163
1164 static int labpc_eeprom_insn_write(struct comedi_device *dev,
1165                                    struct comedi_subdevice *s,
1166                                    struct comedi_insn *insn,
1167                                    unsigned int *data)
1168 {
1169         unsigned int chan = CR_CHAN(insn->chanspec);
1170         int ret;
1171
1172         /* only allow writes to user area of eeprom */
1173         if (chan < 16 || chan > 127)
1174                 return -EINVAL;
1175
1176         /*
1177          * Only write the last data value to the eeprom. Preceding
1178          * data would be overwritten anyway.
1179          */
1180         if (insn->n > 0) {
1181                 unsigned int val = data[insn->n - 1];
1182
1183                 ret = comedi_timeout(dev, s, insn, labpc_eeprom_ready, 0);
1184                 if (ret)
1185                         return ret;
1186
1187                 labpc_eeprom_write(dev, chan, val);
1188                 s->readback[chan] = val;
1189         }
1190
1191         return insn->n;
1192 }
1193
1194 int labpc_common_attach(struct comedi_device *dev,
1195                         unsigned int irq, unsigned long isr_flags)
1196 {
1197         const struct labpc_boardinfo *board = dev->board_ptr;
1198         struct labpc_private *devpriv;
1199         struct comedi_subdevice *s;
1200         int ret;
1201         int i;
1202
1203         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1204         if (!devpriv)
1205                 return -ENOMEM;
1206
1207         if (dev->mmio) {
1208                 devpriv->read_byte = labpc_readb;
1209                 devpriv->write_byte = labpc_writeb;
1210         } else {
1211                 devpriv->read_byte = labpc_inb;
1212                 devpriv->write_byte = labpc_outb;
1213         }
1214
1215         /* initialize board's command registers */
1216         devpriv->write_byte(dev, devpriv->cmd1, CMD1_REG);
1217         devpriv->write_byte(dev, devpriv->cmd2, CMD2_REG);
1218         devpriv->write_byte(dev, devpriv->cmd3, CMD3_REG);
1219         devpriv->write_byte(dev, devpriv->cmd4, CMD4_REG);
1220         if (board->is_labpc1200) {
1221                 devpriv->write_byte(dev, devpriv->cmd5, CMD5_REG);
1222                 devpriv->write_byte(dev, devpriv->cmd6, CMD6_REG);
1223         }
1224
1225         if (irq) {
1226                 ret = request_irq(irq, labpc_interrupt, isr_flags,
1227                                   dev->board_name, dev);
1228                 if (ret == 0)
1229                         dev->irq = irq;
1230         }
1231
1232         if (dev->mmio) {
1233                 dev->pacer = comedi_8254_mm_init(dev->mmio + COUNTER_B_BASE_REG,
1234                                                  I8254_OSC_BASE_2MHZ,
1235                                                  I8254_IO8, 0);
1236                 devpriv->counter = comedi_8254_mm_init(dev->mmio +
1237                                                        COUNTER_A_BASE_REG,
1238                                                        I8254_OSC_BASE_2MHZ,
1239                                                        I8254_IO8, 0);
1240         } else {
1241                 dev->pacer = comedi_8254_init(dev->iobase + COUNTER_B_BASE_REG,
1242                                               I8254_OSC_BASE_2MHZ,
1243                                               I8254_IO8, 0);
1244                 devpriv->counter = comedi_8254_init(dev->iobase +
1245                                                     COUNTER_A_BASE_REG,
1246                                                     I8254_OSC_BASE_2MHZ,
1247                                                     I8254_IO8, 0);
1248         }
1249         if (!dev->pacer || !devpriv->counter)
1250                 return -ENOMEM;
1251
1252         ret = comedi_alloc_subdevices(dev, 5);
1253         if (ret)
1254                 return ret;
1255
1256         /* analog input subdevice */
1257         s = &dev->subdevices[0];
1258         s->type         = COMEDI_SUBD_AI;
1259         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_COMMON | SDF_DIFF;
1260         s->n_chan       = 8;
1261         s->len_chanlist = 8;
1262         s->maxdata      = 0x0fff;
1263         s->range_table  = board->is_labpc1200 ?
1264                           &range_labpc_1200_ai : &range_labpc_plus_ai;
1265         s->insn_read    = labpc_ai_insn_read;
1266         if (dev->irq) {
1267                 dev->read_subdev = s;
1268                 s->subdev_flags |= SDF_CMD_READ;
1269                 s->do_cmd       = labpc_ai_cmd;
1270                 s->do_cmdtest   = labpc_ai_cmdtest;
1271                 s->cancel       = labpc_cancel;
1272         }
1273
1274         /* analog output */
1275         s = &dev->subdevices[1];
1276         if (board->has_ao) {
1277                 s->type         = COMEDI_SUBD_AO;
1278                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_GROUND;
1279                 s->n_chan       = 2;
1280                 s->maxdata      = 0x0fff;
1281                 s->range_table  = &range_labpc_ao;
1282                 s->insn_write   = labpc_ao_insn_write;
1283
1284                 ret = comedi_alloc_subdev_readback(s);
1285                 if (ret)
1286                         return ret;
1287
1288                 /* initialize analog outputs to a known value */
1289                 for (i = 0; i < s->n_chan; i++)
1290                         labpc_ao_write(dev, s, i, s->maxdata / 2);
1291         } else {
1292                 s->type         = COMEDI_SUBD_UNUSED;
1293         }
1294
1295         /* 8255 dio */
1296         s = &dev->subdevices[2];
1297         if (dev->mmio)
1298                 ret = subdev_8255_mm_init(dev, s, NULL, DIO_BASE_REG);
1299         else
1300                 ret = subdev_8255_init(dev, s, NULL, DIO_BASE_REG);
1301         if (ret)
1302                 return ret;
1303
1304         /*  calibration subdevices for boards that have one */
1305         s = &dev->subdevices[3];
1306         if (board->is_labpc1200) {
1307                 s->type         = COMEDI_SUBD_CALIB;
1308                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_INTERNAL;
1309                 s->n_chan       = 16;
1310                 s->maxdata      = 0xff;
1311                 s->insn_write   = labpc_calib_insn_write;
1312
1313                 ret = comedi_alloc_subdev_readback(s);
1314                 if (ret)
1315                         return ret;
1316
1317                 for (i = 0; i < s->n_chan; i++) {
1318                         write_caldac(dev, i, s->maxdata / 2);
1319                         s->readback[i] = s->maxdata / 2;
1320                 }
1321         } else {
1322                 s->type         = COMEDI_SUBD_UNUSED;
1323         }
1324
1325         /* EEPROM (256 bytes) */
1326         s = &dev->subdevices[4];
1327         if (board->is_labpc1200) {
1328                 s->type         = COMEDI_SUBD_MEMORY;
1329                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_INTERNAL;
1330                 s->n_chan       = 256;
1331                 s->maxdata      = 0xff;
1332                 s->insn_write   = labpc_eeprom_insn_write;
1333
1334                 ret = comedi_alloc_subdev_readback(s);
1335                 if (ret)
1336                         return ret;
1337
1338                 for (i = 0; i < s->n_chan; i++)
1339                         s->readback[i] = labpc_eeprom_read(dev, i);
1340         } else {
1341                 s->type         = COMEDI_SUBD_UNUSED;
1342         }
1343
1344         return 0;
1345 }
1346 EXPORT_SYMBOL_GPL(labpc_common_attach);
1347
1348 void labpc_common_detach(struct comedi_device *dev)
1349 {
1350         struct labpc_private *devpriv = dev->private;
1351
1352         if (devpriv)
1353                 kfree(devpriv->counter);
1354 }
1355 EXPORT_SYMBOL_GPL(labpc_common_detach);
1356
1357 static int __init labpc_common_init(void)
1358 {
1359         return 0;
1360 }
1361 module_init(labpc_common_init);
1362
1363 static void __exit labpc_common_exit(void)
1364 {
1365 }
1366 module_exit(labpc_common_exit);
1367
1368 MODULE_AUTHOR("Comedi http://www.comedi.org");
1369 MODULE_DESCRIPTION("Comedi helper for ni_labpc, ni_labpc_pci, ni_labpc_cs");
1370 MODULE_LICENSE("GPL");