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