drivers/staging/comedi/drivers/pcl812.c

   1 /*
   2  * comedi/drivers/pcl812.c
   3  *
   4  * Author: Michal Dobes <dobes@tesnet.cz>
   5  *
   6  * hardware driver for Advantech cards
   7  *  card:   PCL-812, PCL-812PG, PCL-813, PCL-813B
   8  *  driver: pcl812,  pcl812pg,  pcl813,  pcl813b
   9  * and for ADlink cards
  10  *  card:   ACL-8112DG, ACL-8112HG, ACL-8112PG, ACL-8113, ACL-8216
  11  *  driver: acl8112dg,  acl8112hg,  acl8112pg,  acl8113,  acl8216
  12  * and for ICP DAS cards
  13  *  card:   ISO-813, A-821PGH, A-821PGL, A-821PGL-NDA, A-822PGH, A-822PGL,
  14  *  driver: iso813,  a821pgh,  a-821pgl, a-821pglnda,  a822pgh,  a822pgl,
  15  *  card:   A-823PGH, A-823PGL, A-826PG
  16  * driver:  a823pgh,  a823pgl,  a826pg
  17  */
  18
  19 /*
  20  * Driver: pcl812
  21  * Description: Advantech PCL-812/PG, PCL-813/B,
  22  *           ADLink ACL-8112DG/HG/PG, ACL-8113, ACL-8216,
  23  *           ICP DAS A-821PGH/PGL/PGL-NDA, A-822PGH/PGL, A-823PGH/PGL, A-826PG,
  24  *           ICP DAS ISO-813
  25  * Author: Michal Dobes <dobes@tesnet.cz>
  26  * Devices: [Advantech] PCL-812 (pcl812), PCL-812PG (pcl812pg),
  27  *      PCL-813 (pcl813), PCL-813B (pcl813b), [ADLink] ACL-8112DG (acl8112dg),
  28  *      ACL-8112HG (acl8112hg), ACL-8113 (acl-8113), ACL-8216 (acl8216),
  29  *      [ICP] ISO-813 (iso813), A-821PGH (a821pgh), A-821PGL (a821pgl),
  30  *      A-821PGL-NDA (a821pclnda), A-822PGH (a822pgh), A-822PGL (a822pgl),
  31  *      A-823PGH (a823pgh), A-823PGL (a823pgl), A-826PG (a826pg)
  32  * Updated: Mon, 06 Aug 2007 12:03:15 +0100
  33  * Status: works (I hope. My board fire up under my hands
  34  *             and I cann't test all features.)
  35  *
  36  * This driver supports insn and cmd interfaces. Some boards support only insn
  37  * because their hardware don't allow more (PCL-813/B, ACL-8113, ISO-813).
  38  * Data transfer over DMA is supported only when you measure only one
  39  * channel, this is too hardware limitation of these boards.
  40  *
  41  * Options for PCL-812:
  42  *   [0] - IO Base
  43  *   [1] - IRQ  (0=disable, 2, 3, 4, 5, 6, 7; 10, 11, 12, 14, 15)
  44  *   [2] - DMA  (0=disable, 1, 3)
  45  *   [3] - 0=trigger source is internal 8253 with 2MHz clock
  46  *         1=trigger source is external
  47  *   [4] - 0=A/D input range is +/-10V
  48  *         1=A/D input range is +/-5V
  49  *         2=A/D input range is +/-2.5V
  50  *         3=A/D input range is +/-1.25V
  51  *         4=A/D input range is +/-0.625V
  52  *         5=A/D input range is +/-0.3125V
  53  *   [5] - 0=D/A outputs 0-5V  (internal reference -5V)
  54  *         1=D/A outputs 0-10V (internal reference -10V)
  55  *         2=D/A outputs unknown (external reference)
  56  *
  57  * Options for PCL-812PG, ACL-8112PG:
  58  *   [0] - IO Base
  59  *   [1] - IRQ  (0=disable, 2, 3, 4, 5, 6, 7; 10, 11, 12, 14, 15)
  60  *   [2] - DMA  (0=disable, 1, 3)
  61  *   [3] - 0=trigger source is internal 8253 with 2MHz clock
  62  *         1=trigger source is external
  63  *   [4] - 0=A/D have max +/-5V input
  64  *         1=A/D have max +/-10V input
  65  *   [5] - 0=D/A outputs 0-5V  (internal reference -5V)
  66  *         1=D/A outputs 0-10V (internal reference -10V)
  67  *         2=D/A outputs unknown (external reference)
  68  *
  69  * Options for ACL-8112DG/HG, A-822PGL/PGH, A-823PGL/PGH, ACL-8216, A-826PG:
  70  *   [0] - IO Base
  71  *   [1] - IRQ  (0=disable, 2, 3, 4, 5, 6, 7; 10, 11, 12, 14, 15)
  72  *   [2] - DMA  (0=disable, 1, 3)
  73  *   [3] - 0=trigger source is internal 8253 with 2MHz clock
  74  *         1=trigger source is external
  75  *   [4] - 0=A/D channels are S.E.
  76  *         1=A/D channels are DIFF
  77  *   [5] - 0=D/A outputs 0-5V  (internal reference -5V)
  78  *         1=D/A outputs 0-10V (internal reference -10V)
  79  *         2=D/A outputs unknown (external reference)
  80  *
  81  * Options for A-821PGL/PGH:
  82  *   [0] - IO Base
  83  *   [1] - IRQ  (0=disable, 2, 3, 4, 5, 6, 7)
  84  *   [2] - 0=A/D channels are S.E.
  85  *         1=A/D channels are DIFF
  86  *   [3] - 0=D/A output 0-5V  (internal reference -5V)
  87  *         1=D/A output 0-10V (internal reference -10V)
  88  *
  89  * Options for A-821PGL-NDA:
  90  *   [0] - IO Base
  91  *   [1] - IRQ  (0=disable, 2, 3, 4, 5, 6, 7)
  92  *   [2] - 0=A/D channels are S.E.
  93  *         1=A/D channels are DIFF
  94  *
  95  * Options for PCL-813:
  96  *   [0] - IO Base
  97  *
  98  * Options for PCL-813B:
  99  *   [0] - IO Base
 100  *   [1] - 0= bipolar inputs
 101  *         1= unipolar inputs
 102  *
 103  * Options for ACL-8113, ISO-813:
 104  *   [0] - IO Base
 105  *   [1] - 0= 10V bipolar inputs
 106  *         1= 10V unipolar inputs
 107  *         2= 20V bipolar inputs
 108  *         3= 20V unipolar inputs
 109  */
 110
 111 #include <linux/interrupt.h>
 112 #include <linux/gfp.h>
 113 #include "../comedidev.h"
 114
 115 #include <linux/delay.h>
 116 #include <linux/ioport.h>
 117 #include <linux/io.h>
 118 #include <asm/dma.h>
 119
 120 #include "8253.h"
 121
 122 /* hardware types of the cards */
 123 #define boardPCL812PG         0 /* and ACL-8112PG */
 124 #define boardPCL813B          1
 125 #define boardPCL812           2
 126 #define boardPCL813           3
 127 #define boardISO813           5
 128 #define boardACL8113          6
 129 #define boardACL8112          7 /* ACL-8112DG/HG, A-822PGL/PGH, A-823PGL/PGH */
 130 #define boardACL8216          8 /* and ICP DAS A-826PG */
 131 #define boardA821             9 /* PGH, PGL, PGL/NDA versions */
 132
 133 #define PCLx1x_IORANGE       16
 134
 135 #define PCL812_CTR0           0
 136 #define PCL812_CTR1           1
 137 #define PCL812_CTR2           2
 138 #define PCL812_CTRCTL         3
 139 #define PCL812_AD_LO          4
 140 #define PCL812_DA1_LO         4
 141 #define PCL812_AD_HI          5
 142 #define PCL812_DA1_HI         5
 143 #define PCL812_DA2_LO         6
 144 #define PCL812_DI_LO          6
 145 #define PCL812_DA2_HI         7
 146 #define PCL812_DI_HI          7
 147 #define PCL812_CLRINT         8
 148 #define PCL812_GAIN           9
 149 #define PCL812_MUX           10
 150 #define PCL812_MODE          11
 151 #define PCL812_CNTENABLE     10
 152 #define PCL812_SOFTTRIG      12
 153 #define PCL812_DO_LO         13
 154 #define PCL812_DO_HI         14
 155
 156 #define PCL812_DRDY        0x10 /* =0 data ready */
 157
 158 #define ACL8216_STATUS        8 /* 5. bit signalize data ready */
 159
 160 #define ACL8216_DRDY       0x20 /* =0 data ready */
 161
 162 #define MAX_CHANLIST_LEN    256 /* length of scan list */
 163
 164 static const struct comedi_lrange range_pcl812pg_ai = { 5, {
 165                                                             BIP_RANGE(5),
 166                                                             BIP_RANGE(2.5),
 167                                                             BIP_RANGE(1.25),
 168                                                             BIP_RANGE(0.625),
 169                                                             BIP_RANGE(0.3125),
 170                                                             }
 171 };
 172
 173 static const struct comedi_lrange range_pcl812pg2_ai = { 5, {
 174                                                              BIP_RANGE(10),
 175                                                              BIP_RANGE(5),
 176                                                              BIP_RANGE(2.5),
 177                                                              BIP_RANGE(1.25),
 178                                                              BIP_RANGE(0.625),
 179                                                              }
 180 };
 181
 182 static const struct comedi_lrange range812_bipolar1_25 = { 1, {
 183                                                                BIP_RANGE(1.25),
 184                                                                }
 185 };
 186
 187 static const struct comedi_lrange range812_bipolar0_625 = { 1, {
 188                                                                 BIP_RANGE
 189                                                                 (0.625),
 190                                                                 }
 191 };
 192
 193 static const struct comedi_lrange range812_bipolar0_3125 = { 1, {
 194                                                                  BIP_RANGE
 195                                                                  (0.3125),
 196                                                                  }
 197 };
 198
 199 static const struct comedi_lrange range_pcl813b_ai = { 4, {
 200                                                            BIP_RANGE(5),
 201                                                            BIP_RANGE(2.5),
 202                                                            BIP_RANGE(1.25),
 203                                                            BIP_RANGE(0.625),
 204                                                            }
 205 };
 206
 207 static const struct comedi_lrange range_pcl813b2_ai = { 4, {
 208                                                             UNI_RANGE(10),
 209                                                             UNI_RANGE(5),
 210                                                             UNI_RANGE(2.5),
 211                                                             UNI_RANGE(1.25),
 212                                                             }
 213 };
 214
 215 static const struct comedi_lrange range_iso813_1_ai = { 5, {
 216                                                             BIP_RANGE(5),
 217                                                             BIP_RANGE(2.5),
 218                                                             BIP_RANGE(1.25),
 219                                                             BIP_RANGE(0.625),
 220                                                             BIP_RANGE(0.3125),
 221                                                             }
 222 };
 223
 224 static const struct comedi_lrange range_iso813_1_2_ai = { 5, {
 225                                                               UNI_RANGE(10),
 226                                                               UNI_RANGE(5),
 227                                                               UNI_RANGE(2.5),
 228                                                               UNI_RANGE(1.25),
 229                                                               UNI_RANGE(0.625),
 230                                                               }
 231 };
 232
 233 static const struct comedi_lrange range_iso813_2_ai = { 4, {
 234                                                             BIP_RANGE(5),
 235                                                             BIP_RANGE(2.5),
 236                                                             BIP_RANGE(1.25),
 237                                                             BIP_RANGE(0.625),
 238                                                             }
 239 };
 240
 241 static const struct comedi_lrange range_iso813_2_2_ai = { 4, {
 242                                                               UNI_RANGE(10),
 243                                                               UNI_RANGE(5),
 244                                                               UNI_RANGE(2.5),
 245                                                               UNI_RANGE(1.25),
 246                                                               }
 247 };
 248
 249 static const struct comedi_lrange range_acl8113_1_ai = { 4, {
 250                                                              BIP_RANGE(5),
 251                                                              BIP_RANGE(2.5),
 252                                                              BIP_RANGE(1.25),
 253                                                              BIP_RANGE(0.625),
 254                                                              }
 255 };
 256
 257 static const struct comedi_lrange range_acl8113_1_2_ai = { 4, {
 258                                                                UNI_RANGE(10),
 259                                                                UNI_RANGE(5),
 260                                                                UNI_RANGE(2.5),
 261                                                                UNI_RANGE(1.25),
 262                                                                }
 263 };
 264
 265 static const struct comedi_lrange range_acl8113_2_ai = { 3, {
 266                                                              BIP_RANGE(5),
 267                                                              BIP_RANGE(2.5),
 268                                                              BIP_RANGE(1.25),
 269                                                              }
 270 };
 271
 272 static const struct comedi_lrange range_acl8113_2_2_ai = { 3, {
 273                                                                UNI_RANGE(10),
 274                                                                UNI_RANGE(5),
 275                                                                UNI_RANGE(2.5),
 276                                                                }
 277 };
 278
 279 static const struct comedi_lrange range_acl8112dg_ai = { 9, {
 280                                                              BIP_RANGE(5),
 281                                                              BIP_RANGE(2.5),
 282                                                              BIP_RANGE(1.25),
 283                                                              BIP_RANGE(0.625),
 284                                                              UNI_RANGE(10),
 285                                                              UNI_RANGE(5),
 286                                                              UNI_RANGE(2.5),
 287                                                              UNI_RANGE(1.25),
 288                                                              BIP_RANGE(10),
 289                                                              }
 290 };
 291
 292 static const struct comedi_lrange range_acl8112hg_ai = { 12, {
 293                                                               BIP_RANGE(5),
 294                                                               BIP_RANGE(0.5),
 295                                                               BIP_RANGE(0.05),
 296                                                               BIP_RANGE(0.005),
 297                                                               UNI_RANGE(10),
 298                                                               UNI_RANGE(1),
 299                                                               UNI_RANGE(0.1),
 300                                                               UNI_RANGE(0.01),
 301                                                               BIP_RANGE(10),
 302                                                               BIP_RANGE(1),
 303                                                               BIP_RANGE(0.1),
 304                                                               BIP_RANGE(0.01),
 305                                                               }
 306 };
 307
 308 static const struct comedi_lrange range_a821pgh_ai = { 4, {
 309                                                            BIP_RANGE(5),
 310                                                            BIP_RANGE(0.5),
 311                                                            BIP_RANGE(0.05),
 312                                                            BIP_RANGE(0.005),
 313                                                            }
 314 };
 315
 316 struct pcl812_board {
 317
 318         const char *name;       /*  board name */
 319         int board_type;         /*  type of this board */
 320         int n_aichan;           /*  num of AI chans in S.E. */
 321         int n_aichan_diff;      /*  DIFF num of chans */
 322         int n_aochan;           /*  num of DA chans */
 323         int n_dichan;           /*  DI and DO chans */
 324         int n_dochan;
 325         int ai_maxdata;         /*  AI resolution */
 326         unsigned int ai_ns_min; /*  max sample speed of card v ns */
 327         unsigned int i8254_osc_base;    /*  clock base */
 328         const struct comedi_lrange *rangelist_ai;       /*  rangelist for A/D */
 329         const struct comedi_lrange *rangelist_ao;       /*  rangelist for D/A */
 330         unsigned int IRQbits;   /*  allowed IRQ */
 331         unsigned char DMAbits;  /*  allowed DMA chans */
 332         unsigned char io_range; /*  iorange for this board */
 333         unsigned char haveMPC508;       /*  1=board use MPC508A multiplexor */
 334 };
 335
 336 struct pcl812_private {
 337
 338         unsigned char valid;    /*  =1 device is OK */
 339         unsigned char dma;      /*  >0 use dma ( usedDMA channel) */
 340         unsigned char use_diff; /*  =1 diff inputs */
 341         unsigned char use_MPC;  /*  1=board uses MPC508A multiplexor */
 342         unsigned char use_ext_trg;      /*  1=board uses external trigger */
 343         unsigned char range_correction; /*  =1 we must add 1 to range number */
 344         unsigned char old_chan_reg;     /*  lastly used chan/gain pair */
 345         unsigned char old_gain_reg;
 346         unsigned char mode_reg_int;     /*  there is stored INT number for some card */
 347         unsigned char ai_neverending;   /*  =1 we do unlimited AI */
 348         unsigned char ai_eos;   /*  1=EOS wake up */
 349         unsigned char ai_dma;   /*  =1 we use DMA */
 350         unsigned int ai_poll_ptr;       /*  how many sampes transfer poll */
 351         unsigned int ai_scans;  /*  len of scanlist */
 352         unsigned int ai_act_scan;       /*  how many scans we finished */
 353         unsigned int ai_chanlist[MAX_CHANLIST_LEN];     /*  our copy of channel/range list */
 354         unsigned int ai_n_chan; /*  how many channels is measured */
 355         unsigned int ai_flags;  /*  flaglist */
 356         unsigned int ai_data_len;       /*  len of data buffer */
 357         short *ai_data;         /*  data buffer */
 358         unsigned int ai_is16b;  /*  =1 we have 16 bit card */
 359         unsigned long dmabuf[2];        /*  PTR to DMA buf */
 360         unsigned int dmapages[2];       /*  how many pages we have allocated */
 361         unsigned int hwdmaptr[2];       /*  HW PTR to DMA buf */
 362         unsigned int hwdmasize[2];      /*  DMA buf size in bytes */
 363         unsigned int dmabytestomove[2]; /*  how many bytes DMA transfer */
 364         int next_dma_buf;       /*  which buffer is next to use */
 365         unsigned int dma_runs_to_end;   /*  how many times we must switch DMA buffers */
 366         unsigned int last_dma_run;      /*  how many bytes to transfer on last DMA buffer */
 367         unsigned int max_812_ai_mode0_rangewait;        /*  setling time for gain */
 368         unsigned int ao_readback[2];    /*  data for AO readback */
 369 };
 370
 371 #define devpriv ((struct pcl812_private *)dev->private)
 372
 373 /*
 374 ==============================================================================
 375 */
 376 static void start_pacer(struct comedi_device *dev, int mode,
 377                         unsigned int divisor1, unsigned int divisor2);
 378 static void setup_range_channel(struct comedi_device *dev,
 379                                 struct comedi_subdevice *s,
 380                                 unsigned int rangechan, char wait);
 381 static int pcl812_ai_cancel(struct comedi_device *dev,
 382                             struct comedi_subdevice *s);
 383 /*
 384 ==============================================================================
 385 */
 386 static int pcl812_ai_insn_read(struct comedi_device *dev,
 387                                struct comedi_subdevice *s,
 388                                struct comedi_insn *insn, unsigned int *data)
 389 {
 390         int n;
 391         int timeout, hi;
 392
 393         /* select software trigger */
 394         outb(devpriv->mode_reg_int | 1, dev->iobase + PCL812_MODE);
 395         /*  select channel and renge */
 396         setup_range_channel(dev, s, insn->chanspec, 1);
 397         for (n = 0; n < insn->n; n++) {
 398                 /* start conversion */
 399                 outb(255, dev->iobase + PCL812_SOFTTRIG);
 400                 udelay(5);
 401                 timeout = 50;   /* wait max 50us, it must finish under 33us */
 402                 while (timeout--) {
 403                         hi = inb(dev->iobase + PCL812_AD_HI);
 404                         if (!(hi & PCL812_DRDY))
 405                                 goto conv_finish;
 406                         udelay(1);
 407                 }
 408                 printk
 409                     ("comedi%d: pcl812: (%s at 0x%lx) A/D insn read timeout\n",
 410                      dev->minor, dev->board_name, dev->iobase);
 411                 outb(devpriv->mode_reg_int | 0, dev->iobase + PCL812_MODE);
 412                 return -ETIME;
 413
 414 conv_finish:
 415                 data[n] = ((hi & 0xf) << 8) | inb(dev->iobase + PCL812_AD_LO);
 416         }
 417         outb(devpriv->mode_reg_int | 0, dev->iobase + PCL812_MODE);
 418         return n;
 419 }
 420
 421 /*
 422 ==============================================================================
 423 */
 424 static int acl8216_ai_insn_read(struct comedi_device *dev,
 425                                 struct comedi_subdevice *s,
 426                                 struct comedi_insn *insn, unsigned int *data)
 427 {
 428         int n;
 429         int timeout;
 430
 431         /* select software trigger */
 432         outb(1, dev->iobase + PCL812_MODE);
 433         /*  select channel and renge */
 434         setup_range_channel(dev, s, insn->chanspec, 1);
 435         for (n = 0; n < insn->n; n++) {
 436                 /* start conversion */
 437                 outb(255, dev->iobase + PCL812_SOFTTRIG);
 438                 udelay(5);
 439                 timeout = 50;   /* wait max 50us, it must finish under 33us */
 440                 while (timeout--) {
 441                         if (!(inb(dev->iobase + ACL8216_STATUS) & ACL8216_DRDY))
 442                                 goto conv_finish;
 443                         udelay(1);
 444                 }
 445                 printk
 446                     ("comedi%d: pcl812: (%s at 0x%lx) A/D insn read timeout\n",
 447                      dev->minor, dev->board_name, dev->iobase);
 448                 outb(0, dev->iobase + PCL812_MODE);
 449                 return -ETIME;
 450
 451 conv_finish:
 452                 data[n] =
 453                     (inb(dev->iobase +
 454                          PCL812_AD_HI) << 8) | inb(dev->iobase + PCL812_AD_LO);
 455         }
 456         outb(0, dev->iobase + PCL812_MODE);
 457         return n;
 458 }
 459
 460 /*
 461 ==============================================================================
 462 */
 463 static int pcl812_ao_insn_write(struct comedi_device *dev,
 464                                 struct comedi_subdevice *s,
 465                                 struct comedi_insn *insn, unsigned int *data)
 466 {
 467         int chan = CR_CHAN(insn->chanspec);
 468         int i;
 469
 470         for (i = 0; i < insn->n; i++) {
 471                 outb((data[i] & 0xff),
 472                      dev->iobase + (chan ? PCL812_DA2_LO : PCL812_DA1_LO));
 473                 outb((data[i] >> 8) & 0x0f,
 474                      dev->iobase + (chan ? PCL812_DA2_HI : PCL812_DA1_HI));
 475                 devpriv->ao_readback[chan] = data[i];
 476         }
 477
 478         return i;
 479 }
 480
 481 /*
 482 ==============================================================================
 483 */
 484 static int pcl812_ao_insn_read(struct comedi_device *dev,
 485                                struct comedi_subdevice *s,
 486                                struct comedi_insn *insn, unsigned int *data)
 487 {
 488         int chan = CR_CHAN(insn->chanspec);
 489         int i;
 490
 491         for (i = 0; i < insn->n; i++)
 492                 data[i] = devpriv->ao_readback[chan];
 493
 494         return i;
 495 }
 496
 497 /*
 498 ==============================================================================
 499 */
 500 static int pcl812_di_insn_bits(struct comedi_device *dev,
 501                                struct comedi_subdevice *s,
 502                                struct comedi_insn *insn, unsigned int *data)
 503 {
 504         data[1] = inb(dev->iobase + PCL812_DI_LO);
 505         data[1] |= inb(dev->iobase + PCL812_DI_HI) << 8;
 506
 507         return insn->n;
 508 }
 509
 510 /*
 511 ==============================================================================
 512 */
 513 static int pcl812_do_insn_bits(struct comedi_device *dev,
 514                                struct comedi_subdevice *s,
 515                                struct comedi_insn *insn, unsigned int *data)
 516 {
 517         if (data[0]) {
 518                 s->state &= ~data[0];
 519                 s->state |= data[0] & data[1];
 520                 outb(s->state & 0xff, dev->iobase + PCL812_DO_LO);
 521                 outb((s->state >> 8), dev->iobase + PCL812_DO_HI);
 522         }
 523         data[1] = s->state;
 524
 525         return insn->n;
 526 }
 527
 528 /*
 529 ==============================================================================
 530 */
 531 static int pcl812_ai_cmdtest(struct comedi_device *dev,
 532                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
 533 {
 534         const struct pcl812_board *board = comedi_board(dev);
 535         int err = 0;
 536         int tmp, divisor1, divisor2;
 537
 538         /* step 1: make sure trigger sources are trivially valid */
 539
 540         tmp = cmd->start_src;
 541         cmd->start_src &= TRIG_NOW;
 542         if (!cmd->start_src || tmp != cmd->start_src)
 543                 err++;
 544
 545         tmp = cmd->scan_begin_src;
 546         cmd->scan_begin_src &= TRIG_FOLLOW;
 547         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
 548                 err++;
 549
 550         tmp = cmd->convert_src;
 551         if (devpriv->use_ext_trg)
 552                 cmd->convert_src &= TRIG_EXT;
 553         else
 554                 cmd->convert_src &= TRIG_TIMER;
 555
 556         if (!cmd->convert_src || tmp != cmd->convert_src)
 557                 err++;
 558
 559         tmp = cmd->scan_end_src;
 560         cmd->scan_end_src &= TRIG_COUNT;
 561         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
 562                 err++;
 563
 564         tmp = cmd->stop_src;
 565         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
 566         if (!cmd->stop_src || tmp != cmd->stop_src)
 567                 err++;
 568
 569         if (err)
 570                 return 1;
 571
 572         /*
 573          * step 2: make sure trigger sources are
 574          * unique and mutually compatible
 575          */
 576
 577         if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
 578                 err++;
 579
 580         if (err)
 581                 return 2;
 582
 583         /* step 3: make sure arguments are trivially compatible */
 584
 585         if (cmd->start_arg != 0) {
 586                 cmd->start_arg = 0;
 587                 err++;
 588         }
 589
 590         if (cmd->scan_begin_arg != 0) {
 591                 cmd->scan_begin_arg = 0;
 592                 err++;
 593         }
 594
 595         if (cmd->convert_src == TRIG_TIMER) {
 596                 if (cmd->convert_arg < board->ai_ns_min) {
 597                         cmd->convert_arg = board->ai_ns_min;
 598                         err++;
 599                 }
 600         } else {                /* TRIG_EXT */
 601                 if (cmd->convert_arg != 0) {
 602                         cmd->convert_arg = 0;
 603                         err++;
 604                 }
 605         }
 606
 607         if (!cmd->chanlist_len) {
 608                 cmd->chanlist_len = 1;
 609                 err++;
 610         }
 611         if (cmd->chanlist_len > MAX_CHANLIST_LEN) {
 612                 cmd->chanlist_len = board->n_aichan;
 613                 err++;
 614         }
 615         if (cmd->scan_end_arg != cmd->chanlist_len) {
 616                 cmd->scan_end_arg = cmd->chanlist_len;
 617                 err++;
 618         }
 619         if (cmd->stop_src == TRIG_COUNT) {
 620                 if (!cmd->stop_arg) {
 621                         cmd->stop_arg = 1;
 622                         err++;
 623                 }
 624         } else {                /* TRIG_NONE */
 625                 if (cmd->stop_arg != 0) {
 626                         cmd->stop_arg = 0;
 627                         err++;
 628                 }
 629         }
 630
 631         if (err)
 632                 return 3;
 633
 634         /* step 4: fix up any arguments */
 635
 636         if (cmd->convert_src == TRIG_TIMER) {
 637                 tmp = cmd->convert_arg;
 638                 i8253_cascade_ns_to_timer(board->i8254_osc_base, &divisor1,
 639                                           &divisor2, &cmd->convert_arg,
 640                                           cmd->flags & TRIG_ROUND_MASK);
 641                 if (cmd->convert_arg < board->ai_ns_min)
 642                         cmd->convert_arg = board->ai_ns_min;
 643                 if (tmp != cmd->convert_arg)
 644                         err++;
 645         }
 646
 647         if (err)
 648                 return 4;
 649
 650         return 0;
 651 }
 652
 653 /*
 654 ==============================================================================
 655 */
 656 static int pcl812_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 657 {
 658         const struct pcl812_board *board = comedi_board(dev);
 659         unsigned int divisor1 = 0, divisor2 = 0, i, dma_flags, bytes;
 660         struct comedi_cmd *cmd = &s->async->cmd;
 661
 662         if (cmd->start_src != TRIG_NOW)
 663                 return -EINVAL;
 664         if (cmd->scan_begin_src != TRIG_FOLLOW)
 665                 return -EINVAL;
 666         if (devpriv->use_ext_trg) {
 667                 if (cmd->convert_src != TRIG_EXT)
 668                         return -EINVAL;
 669         } else {
 670                 if (cmd->convert_src != TRIG_TIMER)
 671                         return -EINVAL;
 672         }
 673         if (cmd->scan_end_src != TRIG_COUNT)
 674                 return -EINVAL;
 675         if (cmd->scan_end_arg != cmd->chanlist_len)
 676                 return -EINVAL;
 677         if (cmd->chanlist_len > MAX_CHANLIST_LEN)
 678                 return -EINVAL;
 679
 680         if (cmd->convert_src == TRIG_TIMER) {
 681                 if (cmd->convert_arg < board->ai_ns_min)
 682                         cmd->convert_arg = board->ai_ns_min;
 683                 i8253_cascade_ns_to_timer(board->i8254_osc_base,
 684                                           &divisor1, &divisor2,
 685                                           &cmd->convert_arg,
 686                                           cmd->flags & TRIG_ROUND_MASK);
 687         }
 688
 689         start_pacer(dev, -1, 0, 0);     /*  stop pacer */
 690
 691         devpriv->ai_n_chan = cmd->chanlist_len;
 692         memcpy(devpriv->ai_chanlist, cmd->chanlist,
 693                sizeof(unsigned int) * cmd->scan_end_arg);
 694         /*  select first channel and range */
 695         setup_range_channel(dev, s, devpriv->ai_chanlist[0], 1);
 696
 697         if (devpriv->dma) {     /*  check if we can use DMA transfer */
 698                 devpriv->ai_dma = 1;
 699                 for (i = 1; i < devpriv->ai_n_chan; i++)
 700                         if (devpriv->ai_chanlist[0] != devpriv->ai_chanlist[i]) {
 701                                 /*  we cann't use DMA :-( */
 702                                 devpriv->ai_dma = 0;
 703                                 break;
 704                         }
 705         } else
 706                 devpriv->ai_dma = 0;
 707
 708         devpriv->ai_flags = cmd->flags;
 709         devpriv->ai_data_len = s->async->prealloc_bufsz;
 710         devpriv->ai_data = s->async->prealloc_buf;
 711         if (cmd->stop_src == TRIG_COUNT) {
 712                 devpriv->ai_scans = cmd->stop_arg;
 713                 devpriv->ai_neverending = 0;
 714         } else {
 715                 devpriv->ai_scans = 0;
 716                 devpriv->ai_neverending = 1;
 717         }
 718
 719         devpriv->ai_act_scan = 0;
 720         devpriv->ai_poll_ptr = 0;
 721         s->async->cur_chan = 0;
 722
 723         /*  don't we want wake up every scan? */
 724         if ((devpriv->ai_flags & TRIG_WAKE_EOS)) {
 725                 devpriv->ai_eos = 1;
 726
 727                 /*  DMA is useless for this situation */
 728                 if (devpriv->ai_n_chan == 1)
 729                         devpriv->ai_dma = 0;
 730         }
 731
 732         if (devpriv->ai_dma) {
 733                 /*  we use EOS, so adapt DMA buffer to one scan */
 734                 if (devpriv->ai_eos) {
 735                         devpriv->dmabytestomove[0] =
 736                             devpriv->ai_n_chan * sizeof(short);
 737                         devpriv->dmabytestomove[1] =
 738                             devpriv->ai_n_chan * sizeof(short);
 739                         devpriv->dma_runs_to_end = 1;
 740                 } else {
 741                         devpriv->dmabytestomove[0] = devpriv->hwdmasize[0];
 742                         devpriv->dmabytestomove[1] = devpriv->hwdmasize[1];
 743                         if (devpriv->ai_data_len < devpriv->hwdmasize[0])
 744                                 devpriv->dmabytestomove[0] =
 745                                     devpriv->ai_data_len;
 746                         if (devpriv->ai_data_len < devpriv->hwdmasize[1])
 747                                 devpriv->dmabytestomove[1] =
 748                                     devpriv->ai_data_len;
 749                         if (devpriv->ai_neverending) {
 750                                 devpriv->dma_runs_to_end = 1;
 751                         } else {
 752                                 /*  how many samples we must transfer? */
 753                                 bytes = devpriv->ai_n_chan *
 754                                         devpriv->ai_scans * sizeof(short);
 755
 756                                 /*  how many DMA pages we must fill */
 757                                 devpriv->dma_runs_to_end =
 758                                         bytes / devpriv->dmabytestomove[0];
 759
 760                                 /* on last dma transfer must be moved */
 761                                 devpriv->last_dma_run =
 762                                         bytes % devpriv->dmabytestomove[0];
 763                                 if (devpriv->dma_runs_to_end == 0)
 764                                         devpriv->dmabytestomove[0] =
 765                                             devpriv->last_dma_run;
 766                                 devpriv->dma_runs_to_end--;
 767                         }
 768                 }
 769                 if (devpriv->dmabytestomove[0] > devpriv->hwdmasize[0]) {
 770                         devpriv->dmabytestomove[0] = devpriv->hwdmasize[0];
 771                         devpriv->ai_eos = 0;
 772                 }
 773                 if (devpriv->dmabytestomove[1] > devpriv->hwdmasize[1]) {
 774                         devpriv->dmabytestomove[1] = devpriv->hwdmasize[1];
 775                         devpriv->ai_eos = 0;
 776                 }
 777                 devpriv->next_dma_buf = 0;
 778                 set_dma_mode(devpriv->dma, DMA_MODE_READ);
 779                 dma_flags = claim_dma_lock();
 780                 clear_dma_ff(devpriv->dma);
 781                 set_dma_addr(devpriv->dma, devpriv->hwdmaptr[0]);
 782                 set_dma_count(devpriv->dma, devpriv->dmabytestomove[0]);
 783                 release_dma_lock(dma_flags);
 784                 enable_dma(devpriv->dma);
 785         }
 786
 787         switch (cmd->convert_src) {
 788         case TRIG_TIMER:
 789                 start_pacer(dev, 1, divisor1, divisor2);
 790                 break;
 791         }
 792
 793         if (devpriv->ai_dma)                                    /*  let's go! */
 794                 outb(devpriv->mode_reg_int | 2, dev->iobase + PCL812_MODE);
 795         else                                                    /*  let's go! */
 796                 outb(devpriv->mode_reg_int | 6, dev->iobase + PCL812_MODE);
 797
 798         return 0;
 799 }
 800
 801 /*
 802 ==============================================================================
 803 */
 804 static irqreturn_t interrupt_pcl812_ai_int(int irq, void *d)
 805 {
 806         char err = 1;
 807         unsigned int mask, timeout;
 808         struct comedi_device *dev = d;
 809         struct comedi_subdevice *s = dev->subdevices + 0;
 810         unsigned int next_chan;
 811
 812         s->async->events = 0;
 813
 814         timeout = 50;           /* wait max 50us, it must finish under 33us */
 815         if (devpriv->ai_is16b) {
 816                 mask = 0xffff;
 817                 while (timeout--) {
 818                         if (!(inb(dev->iobase + ACL8216_STATUS) & ACL8216_DRDY)) {
 819                                 err = 0;
 820                                 break;
 821                         }
 822                         udelay(1);
 823                 }
 824         } else {
 825                 mask = 0x0fff;
 826                 while (timeout--) {
 827                         if (!(inb(dev->iobase + PCL812_AD_HI) & PCL812_DRDY)) {
 828                                 err = 0;
 829                                 break;
 830                         }
 831                         udelay(1);
 832                 }
 833         }
 834
 835         if (err) {
 836                 printk
 837                     ("comedi%d: pcl812: (%s at 0x%lx) "
 838                      "A/D cmd IRQ without DRDY!\n",
 839                      dev->minor, dev->board_name, dev->iobase);
 840                 pcl812_ai_cancel(dev, s);
 841                 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 842                 comedi_event(dev, s);
 843                 return IRQ_HANDLED;
 844         }
 845
 846         comedi_buf_put(s->async,
 847                        ((inb(dev->iobase + PCL812_AD_HI) << 8) |
 848                         inb(dev->iobase + PCL812_AD_LO)) & mask);
 849
 850         /* Set up next channel. Added by abbotti 2010-01-20, but untested. */
 851         next_chan = s->async->cur_chan + 1;
 852         if (next_chan >= devpriv->ai_n_chan)
 853                 next_chan = 0;
 854         if (devpriv->ai_chanlist[s->async->cur_chan] !=
 855                         devpriv->ai_chanlist[next_chan])
 856                 setup_range_channel(dev, s, devpriv->ai_chanlist[next_chan], 0);
 857
 858         outb(0, dev->iobase + PCL812_CLRINT);   /* clear INT request */
 859
 860         s->async->cur_chan = next_chan;
 861         if (next_chan == 0) {   /* one scan done */
 862                 devpriv->ai_act_scan++;
 863                 if (!(devpriv->ai_neverending))
 864                                                         /* all data sampled */
 865                         if (devpriv->ai_act_scan >= devpriv->ai_scans) {
 866                                 pcl812_ai_cancel(dev, s);
 867                                 s->async->events |= COMEDI_CB_EOA;
 868                         }
 869         }
 870
 871         comedi_event(dev, s);
 872         return IRQ_HANDLED;
 873 }
 874
 875 /*
 876 ==============================================================================
 877 */
 878 static void transfer_from_dma_buf(struct comedi_device *dev,
 879                                   struct comedi_subdevice *s, short *ptr,
 880                                   unsigned int bufptr, unsigned int len)
 881 {
 882         unsigned int i;
 883
 884         s->async->events = 0;
 885         for (i = len; i; i--) {
 886                                                         /*  get one sample */
 887                 comedi_buf_put(s->async, ptr[bufptr++]);
 888
 889                 s->async->cur_chan++;
 890                 if (s->async->cur_chan >= devpriv->ai_n_chan) {
 891                         s->async->cur_chan = 0;
 892                         devpriv->ai_act_scan++;
 893                         if (!devpriv->ai_neverending)
 894                                                         /* all data sampled */
 895                                 if (devpriv->ai_act_scan >= devpriv->ai_scans) {
 896                                         pcl812_ai_cancel(dev, s);
 897                                         s->async->events |= COMEDI_CB_EOA;
 898                                         break;
 899                                 }
 900                 }
 901         }
 902
 903         comedi_event(dev, s);
 904 }
 905
 906 /*
 907 ==============================================================================
 908 */
 909 static irqreturn_t interrupt_pcl812_ai_dma(int irq, void *d)
 910 {
 911         struct comedi_device *dev = d;
 912         struct comedi_subdevice *s = dev->subdevices + 0;
 913         unsigned long dma_flags;
 914         int len, bufptr;
 915         short *ptr;
 916
 917         ptr = (short *)devpriv->dmabuf[devpriv->next_dma_buf];
 918         len = (devpriv->dmabytestomove[devpriv->next_dma_buf] >> 1) -
 919             devpriv->ai_poll_ptr;
 920
 921         devpriv->next_dma_buf = 1 - devpriv->next_dma_buf;
 922         disable_dma(devpriv->dma);
 923         set_dma_mode(devpriv->dma, DMA_MODE_READ);
 924         dma_flags = claim_dma_lock();
 925         set_dma_addr(devpriv->dma, devpriv->hwdmaptr[devpriv->next_dma_buf]);
 926         if (devpriv->ai_eos) {
 927                 set_dma_count(devpriv->dma,
 928                               devpriv->dmabytestomove[devpriv->next_dma_buf]);
 929         } else {
 930                 if (devpriv->dma_runs_to_end) {
 931                         set_dma_count(devpriv->dma,
 932                                       devpriv->dmabytestomove[devpriv->
 933                                                               next_dma_buf]);
 934                 } else {
 935                         set_dma_count(devpriv->dma, devpriv->last_dma_run);
 936                 }
 937                 devpriv->dma_runs_to_end--;
 938         }
 939         release_dma_lock(dma_flags);
 940         enable_dma(devpriv->dma);
 941
 942         outb(0, dev->iobase + PCL812_CLRINT);   /* clear INT request */
 943
 944         bufptr = devpriv->ai_poll_ptr;
 945         devpriv->ai_poll_ptr = 0;
 946
 947         transfer_from_dma_buf(dev, s, ptr, bufptr, len);
 948
 949         return IRQ_HANDLED;
 950 }
 951
 952 /*
 953 ==============================================================================
 954 */
 955 static irqreturn_t interrupt_pcl812(int irq, void *d)
 956 {
 957         struct comedi_device *dev = d;
 958
 959         if (!dev->attached) {
 960                 comedi_error(dev, "spurious interrupt");
 961                 return IRQ_HANDLED;
 962         }
 963         if (devpriv->ai_dma)
 964                 return interrupt_pcl812_ai_dma(irq, d);
 965         else
 966                 return interrupt_pcl812_ai_int(irq, d);
 967 }
 968
 969 /*
 970 ==============================================================================
 971 */
 972 static int pcl812_ai_poll(struct comedi_device *dev, struct comedi_subdevice *s)
 973 {
 974         unsigned long flags;
 975         unsigned int top1, top2, i;
 976
 977         if (!devpriv->ai_dma)
 978                 return 0;       /*  poll is valid only for DMA transfer */
 979
 980         spin_lock_irqsave(&dev->spinlock, flags);
 981
 982         for (i = 0; i < 10; i++) {
 983                 /*  where is now DMA */
 984                 top1 = get_dma_residue(devpriv->ai_dma);
 985                 top2 = get_dma_residue(devpriv->ai_dma);
 986                 if (top1 == top2)
 987                         break;
 988         }
 989
 990         if (top1 != top2) {
 991                 spin_unlock_irqrestore(&dev->spinlock, flags);
 992                 return 0;
 993         }
 994         /*  where is now DMA in buffer */
 995         top1 = devpriv->dmabytestomove[1 - devpriv->next_dma_buf] - top1;
 996         top1 >>= 1;             /*  sample position */
 997         top2 = top1 - devpriv->ai_poll_ptr;
 998         if (top2 < 1) {         /*  no new samples */
 999                 spin_unlock_irqrestore(&dev->spinlock, flags);
1000                 return 0;
1001         }
1002
1003         transfer_from_dma_buf(dev, s,
1004                               (void *)devpriv->dmabuf[1 -
1005                                                       devpriv->next_dma_buf],
1006                               devpriv->ai_poll_ptr, top2);
1007
1008         devpriv->ai_poll_ptr = top1;    /*  new buffer position */
1009
1010         spin_unlock_irqrestore(&dev->spinlock, flags);
1011
1012         return s->async->buf_write_count - s->async->buf_read_count;
1013 }
1014
1015 /*
1016 ==============================================================================
1017 */
1018 static void setup_range_channel(struct comedi_device *dev,
1019                                 struct comedi_subdevice *s,
1020                                 unsigned int rangechan, char wait)
1021 {
1022         unsigned char chan_reg = CR_CHAN(rangechan);    /*  normal board */
1023                                                         /*  gain index */
1024         unsigned char gain_reg = CR_RANGE(rangechan) +
1025                                  devpriv->range_correction;
1026
1027         if ((chan_reg == devpriv->old_chan_reg)
1028             && (gain_reg == devpriv->old_gain_reg))
1029                 return;         /*  we can return, no change */
1030
1031         devpriv->old_chan_reg = chan_reg;
1032         devpriv->old_gain_reg = gain_reg;
1033
1034         if (devpriv->use_MPC) {
1035                 if (devpriv->use_diff) {
1036                         chan_reg = chan_reg | 0x30;     /*  DIFF inputs */
1037                 } else {
1038                         if (chan_reg & 0x80)
1039                                                         /*  SE inputs 8-15 */
1040                                 chan_reg = chan_reg | 0x20;
1041                         else
1042                                                         /*  SE inputs 0-7 */
1043                                 chan_reg = chan_reg | 0x10;
1044                 }
1045         }
1046
1047         outb(chan_reg, dev->iobase + PCL812_MUX);       /* select channel */
1048         outb(gain_reg, dev->iobase + PCL812_GAIN);      /* select gain */
1049
1050
1051         if (wait)
1052                 /*
1053                  * XXX this depends on selected range and can be very long for
1054                  * some high gain ranges!
1055                  */
1056                 udelay(devpriv->max_812_ai_mode0_rangewait);
1057 }
1058
1059 /*
1060 ==============================================================================
1061 */
1062 static void start_pacer(struct comedi_device *dev, int mode,
1063                         unsigned int divisor1, unsigned int divisor2)
1064 {
1065         outb(0xb4, dev->iobase + PCL812_CTRCTL);
1066         outb(0x74, dev->iobase + PCL812_CTRCTL);
1067         udelay(1);
1068
1069         if (mode == 1) {
1070                 outb(divisor2 & 0xff, dev->iobase + PCL812_CTR2);
1071                 outb((divisor2 >> 8) & 0xff, dev->iobase + PCL812_CTR2);
1072                 outb(divisor1 & 0xff, dev->iobase + PCL812_CTR1);
1073                 outb((divisor1 >> 8) & 0xff, dev->iobase + PCL812_CTR1);
1074         }
1075 }
1076
1077 /*
1078 ==============================================================================
1079 */
1080 static void free_resources(struct comedi_device *dev)
1081 {
1082         const struct pcl812_board *board = comedi_board(dev);
1083
1084         if (dev->private) {
1085                 if (devpriv->dmabuf[0])
1086                         free_pages(devpriv->dmabuf[0], devpriv->dmapages[0]);
1087                 if (devpriv->dmabuf[1])
1088                         free_pages(devpriv->dmabuf[1], devpriv->dmapages[1]);
1089                 if (devpriv->dma)
1090                         free_dma(devpriv->dma);
1091         }
1092         if (dev->irq)
1093                 free_irq(dev->irq, dev);
1094         if (dev->iobase)
1095                 release_region(dev->iobase, board->io_range);
1096 }
1097
1098 /*
1099 ==============================================================================
1100 */
1101 static int pcl812_ai_cancel(struct comedi_device *dev,
1102                             struct comedi_subdevice *s)
1103 {
1104         if (devpriv->ai_dma)
1105                 disable_dma(devpriv->dma);
1106         outb(0, dev->iobase + PCL812_CLRINT);   /* clear INT request */
1107                                                         /* Stop A/D */
1108         outb(devpriv->mode_reg_int | 0, dev->iobase + PCL812_MODE);
1109         start_pacer(dev, -1, 0, 0);     /*  stop 8254 */
1110         outb(0, dev->iobase + PCL812_CLRINT);   /* clear INT request */
1111         return 0;
1112 }
1113
1114 /*
1115 ==============================================================================
1116 */
1117 static void pcl812_reset(struct comedi_device *dev)
1118 {
1119         const struct pcl812_board *board = comedi_board(dev);
1120
1121         outb(0, dev->iobase + PCL812_MUX);
1122         outb(0 + devpriv->range_correction, dev->iobase + PCL812_GAIN);
1123         devpriv->old_chan_reg = -1;     /*  invalidate chain/gain memory */
1124         devpriv->old_gain_reg = -1;
1125
1126         switch (board->board_type) {
1127         case boardPCL812PG:
1128         case boardPCL812:
1129         case boardACL8112:
1130         case boardACL8216:
1131                 outb(0, dev->iobase + PCL812_DA2_LO);
1132                 outb(0, dev->iobase + PCL812_DA2_HI);
1133         case boardA821:
1134                 outb(0, dev->iobase + PCL812_DA1_LO);
1135                 outb(0, dev->iobase + PCL812_DA1_HI);
1136                 start_pacer(dev, -1, 0, 0);     /*  stop 8254 */
1137                 outb(0, dev->iobase + PCL812_DO_HI);
1138                 outb(0, dev->iobase + PCL812_DO_LO);
1139                 outb(devpriv->mode_reg_int | 0, dev->iobase + PCL812_MODE);
1140                 outb(0, dev->iobase + PCL812_CLRINT);
1141                 break;
1142         case boardPCL813B:
1143         case boardPCL813:
1144         case boardISO813:
1145         case boardACL8113:
1146                 udelay(5);
1147                 break;
1148         }
1149         udelay(5);
1150 }
1151
1152 static int pcl812_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1153 {
1154         const struct pcl812_board *board = comedi_board(dev);
1155         int ret, subdev;
1156         unsigned long iobase;
1157         unsigned int irq;
1158         unsigned int dma;
1159         unsigned long pages;
1160         struct comedi_subdevice *s;
1161         int n_subdevices;
1162
1163         iobase = it->options[0];
1164         printk(KERN_INFO "comedi%d: pcl812:  board=%s, ioport=0x%03lx",
1165                dev->minor, board->name, iobase);
1166
1167         if (!request_region(iobase, board->io_range, "pcl812")) {
1168                 printk("I/O port conflict\n");
1169                 return -EIO;
1170         }
1171         dev->iobase = iobase;
1172
1173         ret = alloc_private(dev, sizeof(struct pcl812_private));
1174         if (ret < 0) {
1175                 free_resources(dev);
1176                 return ret;     /* Can't alloc mem */
1177         }
1178
1179         dev->board_name = board->name;
1180
1181         irq = 0;
1182         if (board->IRQbits != 0) {      /* board support IRQ */
1183                 irq = it->options[1];
1184                 if (irq) {      /* we want to use IRQ */
1185                         if (((1 << irq) & board->IRQbits) == 0) {
1186                                 printk
1187                                     (", IRQ %u is out of allowed range, "
1188                                      "DISABLING IT", irq);
1189                                 irq = 0;        /* Bad IRQ */
1190                         } else {
1191                                 if (request_irq
1192                                     (irq, interrupt_pcl812, 0, "pcl812", dev)) {
1193                                         printk
1194                                             (", unable to allocate IRQ %u, "
1195                                              "DISABLING IT", irq);
1196                                         irq = 0;        /* Can't use IRQ */
1197                                 } else {
1198                                         printk(KERN_INFO ", irq=%u", irq);
1199                                 }
1200                         }
1201                 }
1202         }
1203
1204         dev->irq = irq;
1205
1206         dma = 0;
1207         devpriv->dma = dma;
1208         if (!dev->irq)
1209                 goto no_dma;    /* if we haven't IRQ, we can't use DMA */
1210         if (board->DMAbits != 0) {      /* board support DMA */
1211                 dma = it->options[2];
1212                 if (((1 << dma) & board->DMAbits) == 0) {
1213                         printk(", DMA is out of allowed range, FAIL!\n");
1214                         return -EINVAL; /* Bad DMA */
1215                 }
1216                 ret = request_dma(dma, "pcl812");
1217                 if (ret) {
1218                         printk(KERN_ERR ", unable to allocate DMA %u, FAIL!\n",
1219                                dma);
1220                         return -EBUSY;  /* DMA isn't free */
1221                 }
1222                 devpriv->dma = dma;
1223                 printk(KERN_INFO ", dma=%u", dma);
1224                 pages = 1;      /* we want 8KB */
1225                 devpriv->dmabuf[0] = __get_dma_pages(GFP_KERNEL, pages);
1226                 if (!devpriv->dmabuf[0]) {
1227                         printk(", unable to allocate DMA buffer, FAIL!\n");
1228                         /*
1229                          * maybe experiment with try_to_free_pages()
1230                          * will help ....
1231                          */
1232                         free_resources(dev);
1233                         return -EBUSY;  /* no buffer :-( */
1234                 }
1235                 devpriv->dmapages[0] = pages;
1236                 devpriv->hwdmaptr[0] = virt_to_bus((void *)devpriv->dmabuf[0]);
1237                 devpriv->hwdmasize[0] = PAGE_SIZE * (1 << pages);
1238                 devpriv->dmabuf[1] = __get_dma_pages(GFP_KERNEL, pages);
1239                 if (!devpriv->dmabuf[1]) {
1240                         printk(KERN_ERR ", unable to allocate DMA buffer, FAIL!\n");
1241                         free_resources(dev);
1242                         return -EBUSY;
1243                 }
1244                 devpriv->dmapages[1] = pages;
1245                 devpriv->hwdmaptr[1] = virt_to_bus((void *)devpriv->dmabuf[1]);
1246                 devpriv->hwdmasize[1] = PAGE_SIZE * (1 << pages);
1247         }
1248 no_dma:
1249
1250         n_subdevices = 0;
1251         if (board->n_aichan > 0)
1252                 n_subdevices++;
1253         if (board->n_aochan > 0)
1254                 n_subdevices++;
1255         if (board->n_dichan > 0)
1256                 n_subdevices++;
1257         if (board->n_dochan > 0)
1258                 n_subdevices++;
1259
1260         ret = comedi_alloc_subdevices(dev, n_subdevices);
1261         if (ret) {
1262                 free_resources(dev);
1263                 return ret;
1264         }
1265
1266         subdev = 0;
1267
1268         /* analog input */
1269         if (board->n_aichan > 0) {
1270                 s = dev->subdevices + subdev;
1271                 s->type = COMEDI_SUBD_AI;
1272                 s->subdev_flags = SDF_READABLE;
1273                 switch (board->board_type) {
1274                 case boardA821:
1275                         if (it->options[2] == 1) {
1276                                 s->n_chan = board->n_aichan_diff;
1277                                 s->subdev_flags |= SDF_DIFF;
1278                                 devpriv->use_diff = 1;
1279                         } else {
1280                                 s->n_chan = board->n_aichan;
1281                                 s->subdev_flags |= SDF_GROUND;
1282                         }
1283                         break;
1284                 case boardACL8112:
1285                 case boardACL8216:
1286                         if (it->options[4] == 1) {
1287                                 s->n_chan = board->n_aichan_diff;
1288                                 s->subdev_flags |= SDF_DIFF;
1289                                 devpriv->use_diff = 1;
1290                         } else {
1291                                 s->n_chan = board->n_aichan;
1292                                 s->subdev_flags |= SDF_GROUND;
1293                         }
1294                         break;
1295                 default:
1296                         s->n_chan = board->n_aichan;
1297                         s->subdev_flags |= SDF_GROUND;
1298                         break;
1299                 }
1300                 s->maxdata = board->ai_maxdata;
1301                 s->len_chanlist = MAX_CHANLIST_LEN;
1302                 s->range_table = board->rangelist_ai;
1303                 if (board->board_type == boardACL8216)
1304                         s->insn_read = acl8216_ai_insn_read;
1305                 else
1306                         s->insn_read = pcl812_ai_insn_read;
1307
1308                 devpriv->use_MPC = board->haveMPC508;
1309                 s->cancel = pcl812_ai_cancel;
1310                 if (dev->irq) {
1311                         dev->read_subdev = s;
1312                         s->subdev_flags |= SDF_CMD_READ;
1313                         s->do_cmdtest = pcl812_ai_cmdtest;
1314                         s->do_cmd = pcl812_ai_cmd;
1315                         s->poll = pcl812_ai_poll;
1316                 }
1317                 switch (board->board_type) {
1318                 case boardPCL812PG:
1319                         if (it->options[4] == 1)
1320                                 s->range_table = &range_pcl812pg2_ai;
1321                         break;
1322                 case boardPCL812:
1323                         switch (it->options[4]) {
1324                         case 0:
1325                                 s->range_table = &range_bipolar10;
1326                                 break;
1327                         case 1:
1328                                 s->range_table = &range_bipolar5;
1329                                 break;
1330                         case 2:
1331                                 s->range_table = &range_bipolar2_5;
1332                                 break;
1333                         case 3:
1334                                 s->range_table = &range812_bipolar1_25;
1335                                 break;
1336                         case 4:
1337                                 s->range_table = &range812_bipolar0_625;
1338                                 break;
1339                         case 5:
1340                                 s->range_table = &range812_bipolar0_3125;
1341                                 break;
1342                         default:
1343                                 s->range_table = &range_bipolar10;
1344                                 break;
1345                                 printk
1346                                     (", incorrect range number %d, changing "
1347                                      "to 0 (+/-10V)", it->options[4]);
1348                                 break;
1349                         }
1350                         break;
1351                         break;
1352                 case boardPCL813B:
1353                         if (it->options[1] == 1)
1354                                 s->range_table = &range_pcl813b2_ai;
1355                         break;
1356                 case boardISO813:
1357                         switch (it->options[1]) {
1358                         case 0:
1359                                 s->range_table = &range_iso813_1_ai;
1360                                 break;
1361                         case 1:
1362                                 s->range_table = &range_iso813_1_2_ai;
1363                                 break;
1364                         case 2:
1365                                 s->range_table = &range_iso813_2_ai;
1366                                 devpriv->range_correction = 1;
1367                                 break;
1368                         case 3:
1369                                 s->range_table = &range_iso813_2_2_ai;
1370                                 devpriv->range_correction = 1;
1371                                 break;
1372                         default:
1373                                 s->range_table = &range_iso813_1_ai;
1374                                 break;
1375                                 printk
1376                                     (", incorrect range number %d, "
1377                                      "changing to 0 ", it->options[1]);
1378                                 break;
1379                         }
1380                         break;
1381                 case boardACL8113:
1382                         switch (it->options[1]) {
1383                         case 0:
1384                                 s->range_table = &range_acl8113_1_ai;
1385                                 break;
1386                         case 1:
1387                                 s->range_table = &range_acl8113_1_2_ai;
1388                                 break;
1389                         case 2:
1390                                 s->range_table = &range_acl8113_2_ai;
1391                                 devpriv->range_correction = 1;
1392                                 break;
1393                         case 3:
1394                                 s->range_table = &range_acl8113_2_2_ai;
1395                                 devpriv->range_correction = 1;
1396                                 break;
1397                         default:
1398                                 s->range_table = &range_acl8113_1_ai;
1399                                 break;
1400                                 printk
1401                                     (", incorrect range number %d, "
1402                                      "changing to 0 ", it->options[1]);
1403                                 break;
1404                         }
1405                         break;
1406                 }
1407                 subdev++;
1408         }
1409
1410         /* analog output */
1411         if (board->n_aochan > 0) {
1412                 s = dev->subdevices + subdev;
1413                 s->type = COMEDI_SUBD_AO;
1414                 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
1415                 s->n_chan = board->n_aochan;
1416                 s->maxdata = 0xfff;
1417                 s->len_chanlist = 1;
1418                 s->range_table = board->rangelist_ao;
1419                 s->insn_read = pcl812_ao_insn_read;
1420                 s->insn_write = pcl812_ao_insn_write;
1421                 switch (board->board_type) {
1422                 case boardA821:
1423                         if (it->options[3] == 1)
1424                                 s->range_table = &range_unipolar10;
1425                         break;
1426                 case boardPCL812:
1427                 case boardACL8112:
1428                 case boardPCL812PG:
1429                 case boardACL8216:
1430                         if (it->options[5] == 1)
1431                                 s->range_table = &range_unipolar10;
1432                         if (it->options[5] == 2)
1433                                 s->range_table = &range_unknown;
1434                         break;
1435                 }
1436                 subdev++;
1437         }
1438
1439         /* digital input */
1440         if (board->n_dichan > 0) {
1441                 s = dev->subdevices + subdev;
1442                 s->type = COMEDI_SUBD_DI;
1443                 s->subdev_flags = SDF_READABLE;
1444                 s->n_chan = board->n_dichan;
1445                 s->maxdata = 1;
1446                 s->len_chanlist = board->n_dichan;
1447                 s->range_table = &range_digital;
1448                 s->insn_bits = pcl812_di_insn_bits;
1449                 subdev++;
1450         }
1451
1452         /* digital output */
1453         if (board->n_dochan > 0) {
1454                 s = dev->subdevices + subdev;
1455                 s->type = COMEDI_SUBD_DO;
1456                 s->subdev_flags = SDF_WRITABLE;
1457                 s->n_chan = board->n_dochan;
1458                 s->maxdata = 1;
1459                 s->len_chanlist = board->n_dochan;
1460                 s->range_table = &range_digital;
1461                 s->insn_bits = pcl812_do_insn_bits;
1462                 subdev++;
1463         }
1464
1465         switch (board->board_type) {
1466         case boardACL8216:
1467                 devpriv->ai_is16b = 1;
1468         case boardPCL812PG:
1469         case boardPCL812:
1470         case boardACL8112:
1471                 devpriv->max_812_ai_mode0_rangewait = 1;
1472                 if (it->options[3] > 0)
1473                                                 /*  we use external trigger */
1474                         devpriv->use_ext_trg = 1;
1475         case boardA821:
1476                 devpriv->max_812_ai_mode0_rangewait = 1;
1477                 devpriv->mode_reg_int = (irq << 4) & 0xf0;
1478                 break;
1479         case boardPCL813B:
1480         case boardPCL813:
1481         case boardISO813:
1482         case boardACL8113:
1483                 /* maybe there must by greatest timeout */
1484                 devpriv->max_812_ai_mode0_rangewait = 5;
1485                 break;
1486         }
1487
1488         printk(KERN_INFO "\n");
1489         devpriv->valid = 1;
1490
1491         pcl812_reset(dev);
1492
1493         return 0;
1494 }
1495
1496 static void pcl812_detach(struct comedi_device *dev)
1497 {
1498         free_resources(dev);
1499 }
1500
1501 static const struct pcl812_board boardtypes[] = {
1502         {"pcl812", boardPCL812, 16, 0, 2, 16, 16, 0x0fff,
1503          33000, 500, &range_bipolar10, &range_unipolar5,
1504          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1505         {"pcl812pg", boardPCL812PG, 16, 0, 2, 16, 16, 0x0fff,
1506          33000, 500, &range_pcl812pg_ai, &range_unipolar5,
1507          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1508         {"acl8112pg", boardPCL812PG, 16, 0, 2, 16, 16, 0x0fff,
1509          10000, 500, &range_pcl812pg_ai, &range_unipolar5,
1510          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1511         {"acl8112dg", boardACL8112, 16, 8, 2, 16, 16, 0x0fff,
1512          10000, 500, &range_acl8112dg_ai, &range_unipolar5,
1513          0xdcfc, 0x0a, PCLx1x_IORANGE, 1},
1514         {"acl8112hg", boardACL8112, 16, 8, 2, 16, 16, 0x0fff,
1515          10000, 500, &range_acl8112hg_ai, &range_unipolar5,
1516          0xdcfc, 0x0a, PCLx1x_IORANGE, 1},
1517         {"a821pgl", boardA821, 16, 8, 1, 16, 16, 0x0fff,
1518          10000, 500, &range_pcl813b_ai, &range_unipolar5,
1519          0x000c, 0x00, PCLx1x_IORANGE, 0},
1520         {"a821pglnda", boardA821, 16, 8, 0, 0, 0, 0x0fff,
1521          10000, 500, &range_pcl813b_ai, NULL,
1522          0x000c, 0x00, PCLx1x_IORANGE, 0},
1523         {"a821pgh", boardA821, 16, 8, 1, 16, 16, 0x0fff,
1524          10000, 500, &range_a821pgh_ai, &range_unipolar5,
1525          0x000c, 0x00, PCLx1x_IORANGE, 0},
1526         {"a822pgl", boardACL8112, 16, 8, 2, 16, 16, 0x0fff,
1527          10000, 500, &range_acl8112dg_ai, &range_unipolar5,
1528          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1529         {"a822pgh", boardACL8112, 16, 8, 2, 16, 16, 0x0fff,
1530          10000, 500, &range_acl8112hg_ai, &range_unipolar5,
1531          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1532         {"a823pgl", boardACL8112, 16, 8, 2, 16, 16, 0x0fff,
1533          8000, 500, &range_acl8112dg_ai, &range_unipolar5,
1534          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1535         {"a823pgh", boardACL8112, 16, 8, 2, 16, 16, 0x0fff,
1536          8000, 500, &range_acl8112hg_ai, &range_unipolar5,
1537          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1538         {"pcl813", boardPCL813, 32, 0, 0, 0, 0, 0x0fff,
1539          0, 0, &range_pcl813b_ai, NULL,
1540          0x0000, 0x00, PCLx1x_IORANGE, 0},
1541         {"pcl813b", boardPCL813B, 32, 0, 0, 0, 0, 0x0fff,
1542          0, 0, &range_pcl813b_ai, NULL,
1543          0x0000, 0x00, PCLx1x_IORANGE, 0},
1544         {"acl8113", boardACL8113, 32, 0, 0, 0, 0, 0x0fff,
1545          0, 0, &range_acl8113_1_ai, NULL,
1546          0x0000, 0x00, PCLx1x_IORANGE, 0},
1547         {"iso813", boardISO813, 32, 0, 0, 0, 0, 0x0fff,
1548          0, 0, &range_iso813_1_ai, NULL,
1549          0x0000, 0x00, PCLx1x_IORANGE, 0},
1550         {"acl8216", boardACL8216, 16, 8, 2, 16, 16, 0xffff,
1551          10000, 500, &range_pcl813b2_ai, &range_unipolar5,
1552          0xdcfc, 0x0a, PCLx1x_IORANGE, 1},
1553         {"a826pg", boardACL8216, 16, 8, 2, 16, 16, 0xffff,
1554          10000, 500, &range_pcl813b2_ai, &range_unipolar5,
1555          0xdcfc, 0x0a, PCLx1x_IORANGE, 0},
1556 };
1557
1558 static struct comedi_driver pcl812_driver = {
1559         .driver_name    = "pcl812",
1560         .module         = THIS_MODULE,
1561         .attach         = pcl812_attach,
1562         .detach         = pcl812_detach,
1563         .board_name     = &boardtypes[0].name,
1564         .num_names      = ARRAY_SIZE(boardtypes),
1565         .offset         = sizeof(struct pcl812_board),
1566 };
1567 module_comedi_driver(pcl812_driver);
1568
1569 MODULE_AUTHOR("Comedi http://www.comedi.org");
1570 MODULE_DESCRIPTION("Comedi low-level driver");
1571 MODULE_LICENSE("GPL");