Pileus Git - ~andy/linux/blob - drivers/staging/comedi/drivers/pcl818.c

   1 /*
   2    comedi/drivers/pcl818.c
   3
   4    Author:  Michal Dobes <dobes@tesnet.cz>
   5
   6    hardware driver for Advantech cards:
   7     card:   PCL-818L, PCL-818H, PCL-818HD, PCL-818HG, PCL-818, PCL-718
   8     driver: pcl818l,  pcl818h,  pcl818hd,  pcl818hg,  pcl818,  pcl718
   9 */
  10 /*
  11 Driver: pcl818
  12 Description: Advantech PCL-818 cards, PCL-718
  13 Author: Michal Dobes <dobes@tesnet.cz>
  14 Devices: [Advantech] PCL-818L (pcl818l), PCL-818H (pcl818h),
  15   PCL-818HD (pcl818hd), PCL-818HG (pcl818hg), PCL-818 (pcl818),
  16   PCL-718 (pcl718)
  17 Status: works
  18
  19 All cards have 16 SE/8 DIFF ADCs, one or two DACs, 16 DI and 16 DO.
  20 Differences are only at maximal sample speed, range list and FIFO
  21 support.
  22 The driver support AI mode 0, 1, 3 other subdevices (AO, DI, DO) support
  23 only mode 0. If DMA/FIFO/INT are disabled then AI support only mode 0.
  24 PCL-818HD and PCL-818HG support 1kword FIFO. Driver support this FIFO
  25 but this code is untested.
  26 A word or two about DMA. Driver support DMA operations at two ways:
  27 1) DMA uses two buffers and after one is filled then is generated
  28    INT and DMA restart with second buffer. With this mode I'm unable run
  29    more that 80Ksamples/secs without data dropouts on K6/233.
  30 2) DMA uses one buffer and run in autoinit mode and the data are
  31    from DMA buffer moved on the fly with 2kHz interrupts from RTC.
  32    This mode is used if the interrupt 8 is available for allocation.
  33    If not, then first DMA mode is used. With this I can run at
  34    full speed one card (100ksamples/secs) or two cards with
  35    60ksamples/secs each (more is problem on account of ISA limitations).
  36    To use this mode you must have compiled  kernel with disabled
  37    "Enhanced Real Time Clock Support".
  38    Maybe you can have problems if you use xntpd or similar.
  39    If you've data dropouts with DMA mode 2 then:
  40     a) disable IDE DMA
  41     b) switch text mode console to fb.
  42
  43    Options for PCL-818L:
  44     [0] - IO Base
  45     [1] - IRQ   (0=disable, 2, 3, 4, 5, 6, 7)
  46     [2] - DMA   (0=disable, 1, 3)
  47     [3] - 0, 10=10MHz clock for 8254
  48               1= 1MHz clock for 8254
  49     [4] - 0,  5=A/D input  -5V.. +5V
  50           1, 10=A/D input -10V..+10V
  51     [5] - 0,  5=D/A output 0-5V  (internal reference -5V)
  52           1, 10=D/A output 0-10V (internal reference -10V)
  53           2    =D/A output unknown (external reference)
  54
  55    Options for PCL-818, PCL-818H:
  56     [0] - IO Base
  57     [1] - IRQ   (0=disable, 2, 3, 4, 5, 6, 7)
  58     [2] - DMA   (0=disable, 1, 3)
  59     [3] - 0, 10=10MHz clock for 8254
  60               1= 1MHz clock for 8254
  61     [4] - 0,  5=D/A output 0-5V  (internal reference -5V)
  62           1, 10=D/A output 0-10V (internal reference -10V)
  63           2    =D/A output unknown (external reference)
  64
  65    Options for PCL-818HD, PCL-818HG:
  66     [0] - IO Base
  67     [1] - IRQ   (0=disable, 2, 3, 4, 5, 6, 7)
  68     [2] - DMA/FIFO  (-1=use FIFO, 0=disable both FIFO and DMA,
  69                       1=use DMA ch 1, 3=use DMA ch 3)
  70     [3] - 0, 10=10MHz clock for 8254
  71               1= 1MHz clock for 8254
  72     [4] - 0,  5=D/A output 0-5V  (internal reference -5V)
  73           1, 10=D/A output 0-10V (internal reference -10V)
  74           2    =D/A output unknown (external reference)
  75
  76    Options for PCL-718:
  77     [0] - IO Base
  78     [1] - IRQ   (0=disable, 2, 3, 4, 5, 6, 7)
  79     [2] - DMA   (0=disable, 1, 3)
  80     [3] - 0, 10=10MHz clock for 8254
  81               1= 1MHz clock for 8254
  82     [4] -     0=A/D Range is +/-10V
  83               1=             +/-5V
  84               2=             +/-2.5V
  85               3=             +/-1V
  86               4=             +/-0.5V
  87               5=             user defined bipolar
  88               6=             0-10V
  89               7=             0-5V
  90               8=             0-2V
  91               9=             0-1V
  92              10=             user defined unipolar
  93     [5] - 0,  5=D/A outputs 0-5V  (internal reference -5V)
  94           1, 10=D/A outputs 0-10V (internal reference -10V)
  95               2=D/A outputs unknown (external reference)
  96     [6] - 0, 60=max  60kHz A/D sampling
  97           1,100=max 100kHz A/D sampling (PCL-718 with Option 001 installed)
  98
  99 */
 100
 101 #include "../comedidev.h"
 102
 103 #include <linux/ioport.h>
 104 #include <linux/mc146818rtc.h>
 105 #include <linux/gfp.h>
 106 #include <linux/delay.h>
 107 #include <linux/io.h>
 108 #include <asm/dma.h>
 109
 110 #include "comedi_fc.h"
 111 #include "8253.h"
 112
 113 /* #define PCL818_MODE13_AO 1 */
 114
 115 /* boards constants */
 116
 117 #define boardPCL818L 0
 118 #define boardPCL818H 1
 119 #define boardPCL818HD 2
 120 #define boardPCL818HG 3
 121 #define boardPCL818 4
 122 #define boardPCL718 5
 123
 124 /* IO space len */
 125 #define PCLx1x_RANGE 16
 126 /* IO space len if we use FIFO */
 127 #define PCLx1xFIFO_RANGE 32
 128
 129 /* W: clear INT request */
 130 #define PCL818_CLRINT 8
 131 /* R: return status byte */
 132 #define PCL818_STATUS 8
 133 /* R: A/D high byte W: A/D range control */
 134 #define PCL818_RANGE 1
 135 /* R: next mux scan channel W: mux scan channel & range control pointer */
 136 #define PCL818_MUX 2
 137 /* R/W: operation control register */
 138 #define PCL818_CONTROL 9
 139 /* W: counter enable */
 140 #define PCL818_CNTENABLE 10
 141
 142 /* R: low byte of A/D W: soft A/D trigger */
 143 #define PCL818_AD_LO 0
 144 /* R: high byte of A/D W: A/D range control */
 145 #define PCL818_AD_HI 1
 146 /* W: D/A low&high byte */
 147 #define PCL818_DA_LO 4
 148 #define PCL818_DA_HI 5
 149 /* R: low&high byte of DI */
 150 #define PCL818_DI_LO 3
 151 #define PCL818_DI_HI 11
 152 /* W: low&high byte of DO */
 153 #define PCL818_DO_LO 3
 154 #define PCL818_DO_HI 11
 155 /* W: PCL718 second D/A */
 156 #define PCL718_DA2_LO 6
 157 #define PCL718_DA2_HI 7
 158 /* counters */
 159 #define PCL818_CTR0 12
 160 #define PCL818_CTR1 13
 161 #define PCL818_CTR2 14
 162 /* W: counter control */
 163 #define PCL818_CTRCTL 15
 164
 165 /* W: fifo enable/disable */
 166 #define PCL818_FI_ENABLE 6
 167 /* W: fifo interrupt clear */
 168 #define PCL818_FI_INTCLR 20
 169 /* W: fifo interrupt clear */
 170 #define PCL818_FI_FLUSH 25
 171 /* R: fifo status */
 172 #define PCL818_FI_STATUS 25
 173 /* R: one record from FIFO */
 174 #define PCL818_FI_DATALO 23
 175 #define PCL818_FI_DATAHI 23
 176
 177 /* type of interrupt handler */
 178 #define INT_TYPE_AI1_INT 1
 179 #define INT_TYPE_AI1_DMA 2
 180 #define INT_TYPE_AI1_FIFO 3
 181 #define INT_TYPE_AI3_INT 4
 182 #define INT_TYPE_AI3_DMA 5
 183 #define INT_TYPE_AI3_FIFO 6
 184 #ifdef PCL818_MODE13_AO
 185 #define INT_TYPE_AO1_INT 7
 186 #define INT_TYPE_AO3_INT 8
 187 #endif
 188
 189 #ifdef unused
 190 /* RTC stuff... */
 191 #define INT_TYPE_AI1_DMA_RTC 9
 192 #define INT_TYPE_AI3_DMA_RTC 10
 193
 194 #define RTC_IRQ         8
 195 #define RTC_IO_EXTENT   0x10
 196 #endif
 197
 198 #define MAGIC_DMA_WORD 0x5a5a
 199
 200 static const struct comedi_lrange range_pcl818h_ai = { 9, {
 201                                                            BIP_RANGE(5),
 202                                                            BIP_RANGE(2.5),
 203                                                            BIP_RANGE(1.25),
 204                                                            BIP_RANGE(0.625),
 205                                                            UNI_RANGE(10),
 206                                                            UNI_RANGE(5),
 207                                                            UNI_RANGE(2.5),
 208                                                            UNI_RANGE(1.25),
 209                                                            BIP_RANGE(10),
 210                                                            }
 211 };
 212
 213 static const struct comedi_lrange range_pcl818hg_ai = { 10, {
 214                                                              BIP_RANGE(5),
 215                                                              BIP_RANGE(0.5),
 216                                                              BIP_RANGE(0.05),
 217                                                              BIP_RANGE(0.005),
 218                                                              UNI_RANGE(10),
 219                                                              UNI_RANGE(1),
 220                                                              UNI_RANGE(0.1),
 221                                                              UNI_RANGE(0.01),
 222                                                              BIP_RANGE(10),
 223                                                              BIP_RANGE(1),
 224                                                              BIP_RANGE(0.1),
 225                                                              BIP_RANGE(0.01),
 226                                                              }
 227 };
 228
 229 static const struct comedi_lrange range_pcl818l_l_ai = { 4, {
 230                                                              BIP_RANGE(5),
 231                                                              BIP_RANGE(2.5),
 232                                                              BIP_RANGE(1.25),
 233                                                              BIP_RANGE(0.625),
 234                                                              }
 235 };
 236
 237 static const struct comedi_lrange range_pcl818l_h_ai = { 4, {
 238                                                              BIP_RANGE(10),
 239                                                              BIP_RANGE(5),
 240                                                              BIP_RANGE(2.5),
 241                                                              BIP_RANGE(1.25),
 242                                                              }
 243 };
 244
 245 static const struct comedi_lrange range718_bipolar1 = { 1, {BIP_RANGE(1),} };
 246 static const struct comedi_lrange range718_bipolar0_5 =
 247     { 1, {BIP_RANGE(0.5),} };
 248 static const struct comedi_lrange range718_unipolar2 = { 1, {UNI_RANGE(2),} };
 249 static const struct comedi_lrange range718_unipolar1 = { 1, {BIP_RANGE(1),} };
 250
 251 #ifdef unused
 252 static int RTC_lock;    /* RTC lock */
 253 static int RTC_timer_lock;      /* RTC int lock */
 254 #endif
 255
 256 struct pcl818_board {
 257
 258         const char *name;       /*  driver name */
 259         int n_ranges;           /*  len of range list */
 260         int n_aichan_se;        /*  num of A/D chans in single ended  mode */
 261         int n_aichan_diff;      /*  num of A/D chans in diferencial mode */
 262         unsigned int ns_min;    /*  minimal allowed delay between samples (in ns) */
 263         int n_aochan;           /*  num of D/A chans */
 264         int n_dichan;           /*  num of DI chans */
 265         int n_dochan;           /*  num of DO chans */
 266         const struct comedi_lrange *ai_range_type;      /*  default A/D rangelist */
 267         const struct comedi_lrange *ao_range_type;      /*  default D/A rangelist */
 268         unsigned int io_range;  /*  len of IO space */
 269         unsigned int IRQbits;   /*  allowed interrupts */
 270         unsigned int DMAbits;   /*  allowed DMA chans */
 271         int ai_maxdata;         /*  maxdata for A/D */
 272         int ao_maxdata;         /*  maxdata for D/A */
 273         unsigned char fifo;     /*  1=board has FIFO */
 274         int is_818;
 275 };
 276
 277 struct pcl818_private {
 278
 279         unsigned int dma;       /*  used DMA, 0=don't use DMA */
 280         int dma_rtc;            /*  1=RTC used with DMA, 0=no RTC alloc */
 281         unsigned int io_range;
 282 #ifdef unused
 283         unsigned long rtc_iobase;       /*  RTC port region */
 284         unsigned int rtc_iosize;
 285         unsigned int rtc_irq;
 286         struct timer_list rtc_irq_timer;        /*  timer for RTC sanity check */
 287         unsigned long rtc_freq; /*  RTC int freq */
 288         int rtc_irq_blocked;    /*  1=we now do AI with DMA&RTC */
 289 #endif
 290         unsigned long dmabuf[2];        /*  pointers to begin of DMA buffers */
 291         unsigned int dmapages[2];       /*  len of DMA buffers in PAGE_SIZEs */
 292         unsigned int hwdmaptr[2];       /*  hardware address of DMA buffers */
 293         unsigned int hwdmasize[2];      /*  len of DMA buffers in Bytes */
 294         unsigned int dmasamplsize;      /*  size in samples hwdmasize[0]/2 */
 295         unsigned int last_top_dma;      /*  DMA pointer in last RTC int */
 296         int next_dma_buf;       /*  which DMA buffer will be used next round */
 297         long dma_runs_to_end;   /*  how many we must permorm DMA transfer to end of record */
 298         unsigned long last_dma_run;     /*  how many bytes we must transfer on last DMA page */
 299         unsigned char neverending_ai;   /*  if=1, then we do neverending record (you must use cancel()) */
 300         unsigned int ns_min;    /*  manimal allowed delay between samples (in us) for actual card */
 301         int i8253_osc_base;     /*  1/frequency of on board oscilator in ns */
 302         int irq_free;           /*  1=have allocated IRQ */
 303         int irq_blocked;        /*  1=IRQ now uses any subdev */
 304         int irq_was_now_closed; /*  when IRQ finish, there's stored int818_mode for last interrupt */
 305         int ai_mode;            /*  who now uses IRQ - 1=AI1 int, 2=AI1 dma, 3=AI3 int, 4AI3 dma */
 306         struct comedi_subdevice *last_int_sub;  /*  ptr to subdevice which now finish */
 307         int ai_act_scan;        /*  how many scans we finished */
 308         int ai_act_chan;        /*  actual position in actual scan */
 309         unsigned int act_chanlist[16];  /*  MUX setting for actual AI operations */
 310         unsigned int act_chanlist_len;  /*  how long is actual MUX list */
 311         unsigned int act_chanlist_pos;  /*  actual position in MUX list */
 312         unsigned int ai_scans;  /*  len of scanlist */
 313         unsigned int ai_n_chan; /*  how many channels is measured */
 314         unsigned int *ai_chanlist;      /*  actaul chanlist */
 315         unsigned int ai_flags;  /*  flaglist */
 316         unsigned int ai_data_len;       /*  len of data buffer */
 317         short *ai_data;         /*  data buffer */
 318         unsigned int ai_timer1; /*  timers */
 319         unsigned int ai_timer2;
 320         struct comedi_subdevice *sub_ai;        /*  ptr to AI subdevice */
 321         unsigned char usefifo;  /*  1=use fifo */
 322         unsigned int ao_readback[2];
 323 };
 324
 325 static const unsigned int muxonechan[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,      /*  used for gain list programming */
 326         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
 327 };
 328
 329 /*
 330 ==============================================================================
 331 */
 332 static void setup_channel_list(struct comedi_device *dev,
 333                                struct comedi_subdevice *s,
 334                                unsigned int *chanlist, unsigned int n_chan,
 335                                unsigned int seglen);
 336 static int check_channel_list(struct comedi_device *dev,
 337                               struct comedi_subdevice *s,
 338                               unsigned int *chanlist, unsigned int n_chan);
 339
 340 static int pcl818_ai_cancel(struct comedi_device *dev,
 341                             struct comedi_subdevice *s);
 342 static void start_pacer(struct comedi_device *dev, int mode,
 343                         unsigned int divisor1, unsigned int divisor2);
 344
 345 #ifdef unused
 346 static int set_rtc_irq_bit(unsigned char bit);
 347 static void rtc_dropped_irq(unsigned long data);
 348 static int rtc_setfreq_irq(int freq);
 349 #endif
 350
 351 /*
 352 ==============================================================================
 353    ANALOG INPUT MODE0, 818 cards, slow version
 354 */
 355 static int pcl818_ai_insn_read(struct comedi_device *dev,
 356                                struct comedi_subdevice *s,
 357                                struct comedi_insn *insn, unsigned int *data)
 358 {
 359         int n;
 360         int timeout;
 361
 362         /* software trigger, DMA and INT off */
 363         outb(0, dev->iobase + PCL818_CONTROL);
 364
 365         /* select channel */
 366         outb(muxonechan[CR_CHAN(insn->chanspec)], dev->iobase + PCL818_MUX);
 367
 368         /* select gain */
 369         outb(CR_RANGE(insn->chanspec), dev->iobase + PCL818_RANGE);
 370
 371         for (n = 0; n < insn->n; n++) {
 372
 373                 /* clear INT (conversion end) flag */
 374                 outb(0, dev->iobase + PCL818_CLRINT);
 375
 376                 /* start conversion */
 377                 outb(0, dev->iobase + PCL818_AD_LO);
 378
 379                 timeout = 100;
 380                 while (timeout--) {
 381                         if (inb(dev->iobase + PCL818_STATUS) & 0x10)
 382                                 goto conv_finish;
 383                         udelay(1);
 384                 }
 385                 comedi_error(dev, "A/D insn timeout");
 386                 /* clear INT (conversion end) flag */
 387                 outb(0, dev->iobase + PCL818_CLRINT);
 388                 return -EIO;
 389
 390 conv_finish:
 391                 data[n] = ((inb(dev->iobase + PCL818_AD_HI) << 4) |
 392                            (inb(dev->iobase + PCL818_AD_LO) >> 4));
 393         }
 394
 395         return n;
 396 }
 397
 398 /*
 399 ==============================================================================
 400    ANALOG OUTPUT MODE0, 818 cards
 401    only one sample per call is supported
 402 */
 403 static int pcl818_ao_insn_read(struct comedi_device *dev,
 404                                struct comedi_subdevice *s,
 405                                struct comedi_insn *insn, unsigned int *data)
 406 {
 407         struct pcl818_private *devpriv = dev->private;
 408         int n;
 409         int chan = CR_CHAN(insn->chanspec);
 410
 411         for (n = 0; n < insn->n; n++)
 412                 data[n] = devpriv->ao_readback[chan];
 413
 414         return n;
 415 }
 416
 417 static int pcl818_ao_insn_write(struct comedi_device *dev,
 418                                 struct comedi_subdevice *s,
 419                                 struct comedi_insn *insn, unsigned int *data)
 420 {
 421         struct pcl818_private *devpriv = dev->private;
 422         int n;
 423         int chan = CR_CHAN(insn->chanspec);
 424
 425         for (n = 0; n < insn->n; n++) {
 426                 devpriv->ao_readback[chan] = data[n];
 427                 outb((data[n] & 0x000f) << 4, dev->iobase +
 428                      (chan ? PCL718_DA2_LO : PCL818_DA_LO));
 429                 outb((data[n] & 0x0ff0) >> 4, dev->iobase +
 430                      (chan ? PCL718_DA2_HI : PCL818_DA_HI));
 431         }
 432
 433         return n;
 434 }
 435
 436 /*
 437 ==============================================================================
 438    DIGITAL INPUT MODE0, 818 cards
 439
 440    only one sample per call is supported
 441 */
 442 static int pcl818_di_insn_bits(struct comedi_device *dev,
 443                                struct comedi_subdevice *s,
 444                                struct comedi_insn *insn, unsigned int *data)
 445 {
 446         data[1] = inb(dev->iobase + PCL818_DI_LO) |
 447             (inb(dev->iobase + PCL818_DI_HI) << 8);
 448
 449         return insn->n;
 450 }
 451
 452 /*
 453 ==============================================================================
 454    DIGITAL OUTPUT MODE0, 818 cards
 455
 456    only one sample per call is supported
 457 */
 458 static int pcl818_do_insn_bits(struct comedi_device *dev,
 459                                struct comedi_subdevice *s,
 460                                struct comedi_insn *insn, unsigned int *data)
 461 {
 462         s->state &= ~data[0];
 463         s->state |= (data[0] & data[1]);
 464
 465         outb(s->state & 0xff, dev->iobase + PCL818_DO_LO);
 466         outb((s->state >> 8), dev->iobase + PCL818_DO_HI);
 467
 468         data[1] = s->state;
 469
 470         return insn->n;
 471 }
 472
 473 /*
 474 ==============================================================================
 475    analog input interrupt mode 1 & 3, 818 cards
 476    one sample per interrupt version
 477 */
 478 static irqreturn_t interrupt_pcl818_ai_mode13_int(int irq, void *d)
 479 {
 480         struct comedi_device *dev = d;
 481         struct pcl818_private *devpriv = dev->private;
 482         struct comedi_subdevice *s = &dev->subdevices[0];
 483         int low;
 484         int timeout = 50;       /* wait max 50us */
 485
 486         while (timeout--) {
 487                 if (inb(dev->iobase + PCL818_STATUS) & 0x10)
 488                         goto conv_finish;
 489                 udelay(1);
 490         }
 491         outb(0, dev->iobase + PCL818_STATUS);   /* clear INT request */
 492         comedi_error(dev, "A/D mode1/3 IRQ without DRDY!");
 493         pcl818_ai_cancel(dev, s);
 494         s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 495         comedi_event(dev, s);
 496         return IRQ_HANDLED;
 497
 498 conv_finish:
 499         low = inb(dev->iobase + PCL818_AD_LO);
 500         comedi_buf_put(s->async, ((inb(dev->iobase + PCL818_AD_HI) << 4) | (low >> 4)));        /*  get one sample */
 501         outb(0, dev->iobase + PCL818_CLRINT);   /* clear INT request */
 502
 503         if ((low & 0xf) != devpriv->act_chanlist[devpriv->act_chanlist_pos]) {  /*  dropout! */
 504                 printk
 505                     ("comedi: A/D mode1/3 IRQ - channel dropout %x!=%x !\n",
 506                      (low & 0xf),
 507                      devpriv->act_chanlist[devpriv->act_chanlist_pos]);
 508                 pcl818_ai_cancel(dev, s);
 509                 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 510                 comedi_event(dev, s);
 511                 return IRQ_HANDLED;
 512         }
 513         devpriv->act_chanlist_pos++;
 514         if (devpriv->act_chanlist_pos >= devpriv->act_chanlist_len)
 515                 devpriv->act_chanlist_pos = 0;
 516
 517         s->async->cur_chan++;
 518         if (s->async->cur_chan >= devpriv->ai_n_chan) {
 519                 /*  printk("E"); */
 520                 s->async->cur_chan = 0;
 521                 devpriv->ai_act_scan--;
 522         }
 523
 524         if (!devpriv->neverending_ai) {
 525                 if (devpriv->ai_act_scan == 0) {        /* all data sampled */
 526                         pcl818_ai_cancel(dev, s);
 527                         s->async->events |= COMEDI_CB_EOA;
 528                 }
 529         }
 530         comedi_event(dev, s);
 531         return IRQ_HANDLED;
 532 }
 533
 534 /*
 535 ==============================================================================
 536    analog input dma mode 1 & 3, 818 cards
 537 */
 538 static irqreturn_t interrupt_pcl818_ai_mode13_dma(int irq, void *d)
 539 {
 540         struct comedi_device *dev = d;
 541         struct pcl818_private *devpriv = dev->private;
 542         struct comedi_subdevice *s = &dev->subdevices[0];
 543         int i, len, bufptr;
 544         unsigned long flags;
 545         short *ptr;
 546
 547         disable_dma(devpriv->dma);
 548         devpriv->next_dma_buf = 1 - devpriv->next_dma_buf;
 549         if ((devpriv->dma_runs_to_end) > -1 || devpriv->neverending_ai) {       /*  switch dma bufs */
 550                 set_dma_mode(devpriv->dma, DMA_MODE_READ);
 551                 flags = claim_dma_lock();
 552                 set_dma_addr(devpriv->dma,
 553                              devpriv->hwdmaptr[devpriv->next_dma_buf]);
 554                 if (devpriv->dma_runs_to_end || devpriv->neverending_ai) {
 555                         set_dma_count(devpriv->dma,
 556                                       devpriv->hwdmasize[devpriv->
 557                                                          next_dma_buf]);
 558                 } else {
 559                         set_dma_count(devpriv->dma, devpriv->last_dma_run);
 560                 }
 561                 release_dma_lock(flags);
 562                 enable_dma(devpriv->dma);
 563         }
 564         printk("comedi: A/D mode1/3 IRQ \n");
 565
 566         devpriv->dma_runs_to_end--;
 567         outb(0, dev->iobase + PCL818_CLRINT);   /* clear INT request */
 568         ptr = (short *)devpriv->dmabuf[1 - devpriv->next_dma_buf];
 569
 570         len = devpriv->hwdmasize[0] >> 1;
 571         bufptr = 0;
 572
 573         for (i = 0; i < len; i++) {
 574                 if ((ptr[bufptr] & 0xf) != devpriv->act_chanlist[devpriv->act_chanlist_pos]) {  /*  dropout! */
 575                         printk
 576                             ("comedi: A/D mode1/3 DMA - channel dropout %d(card)!=%d(chanlist) at %d !\n",
 577                              (ptr[bufptr] & 0xf),
 578                              devpriv->act_chanlist[devpriv->act_chanlist_pos],
 579                              devpriv->act_chanlist_pos);
 580                         pcl818_ai_cancel(dev, s);
 581                         s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 582                         comedi_event(dev, s);
 583                         return IRQ_HANDLED;
 584                 }
 585
 586                 comedi_buf_put(s->async, ptr[bufptr++] >> 4);   /*  get one sample */
 587
 588                 devpriv->act_chanlist_pos++;
 589                 if (devpriv->act_chanlist_pos >= devpriv->act_chanlist_len)
 590                         devpriv->act_chanlist_pos = 0;
 591
 592                 s->async->cur_chan++;
 593                 if (s->async->cur_chan >= devpriv->ai_n_chan) {
 594                         s->async->cur_chan = 0;
 595                         devpriv->ai_act_scan--;
 596                 }
 597
 598                 if (!devpriv->neverending_ai)
 599                         if (devpriv->ai_act_scan == 0) {        /* all data sampled */
 600                                 pcl818_ai_cancel(dev, s);
 601                                 s->async->events |= COMEDI_CB_EOA;
 602                                 comedi_event(dev, s);
 603                                 /*  printk("done int ai13 dma\n"); */
 604                                 return IRQ_HANDLED;
 605                         }
 606         }
 607
 608         if (len > 0)
 609                 comedi_event(dev, s);
 610         return IRQ_HANDLED;
 611 }
 612
 613 #ifdef unused
 614 /*
 615 ==============================================================================
 616    analog input dma mode 1 & 3 over RTC, 818 cards
 617 */
 618 static irqreturn_t interrupt_pcl818_ai_mode13_dma_rtc(int irq, void *d)
 619 {
 620         struct comedi_device *dev = d;
 621         struct pcl818_private *devpriv = dev->private;
 622         struct comedi_subdevice *s = &dev->subdevices[0];
 623         unsigned long tmp;
 624         unsigned int top1, top2, i, bufptr;
 625         long ofs_dats;
 626         short *dmabuf = (short *)devpriv->dmabuf[0];
 627
 628         /* outb(2,0x378); */
 629         switch (devpriv->ai_mode) {
 630         case INT_TYPE_AI1_DMA_RTC:
 631         case INT_TYPE_AI3_DMA_RTC:
 632                 tmp = (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
 633                 mod_timer(&devpriv->rtc_irq_timer,
 634                           jiffies + HZ / devpriv->rtc_freq + 2 * HZ / 100);
 635
 636                 for (i = 0; i < 10; i++) {
 637                         top1 = get_dma_residue(devpriv->dma);
 638                         top2 = get_dma_residue(devpriv->dma);
 639                         if (top1 == top2)
 640                                 break;
 641                 }
 642
 643                 if (top1 != top2)
 644                         return IRQ_HANDLED;
 645                 top1 = devpriv->hwdmasize[0] - top1;    /*  where is now DMA in buffer */
 646                 top1 >>= 1;
 647                 ofs_dats = top1 - devpriv->last_top_dma;        /*  new samples from last call */
 648                 if (ofs_dats < 0)
 649                         ofs_dats = (devpriv->dmasamplsize) + ofs_dats;
 650                 if (!ofs_dats)
 651                         return IRQ_HANDLED;     /*  exit=no new samples from last call */
 652                 /*  obsluz data */
 653                 i = devpriv->last_top_dma - 1;
 654                 i &= (devpriv->dmasamplsize - 1);
 655
 656                 if (dmabuf[i] != MAGIC_DMA_WORD) {      /*  DMA overflow! */
 657                         comedi_error(dev, "A/D mode1/3 DMA buffer overflow!");
 658                         /* printk("I %d dmabuf[i] %d %d\n",i,dmabuf[i],devpriv->dmasamplsize); */
 659                         pcl818_ai_cancel(dev, s);
 660                         s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 661                         comedi_event(dev, s);
 662                         return IRQ_HANDLED;
 663                 }
 664                 /* printk("r %ld ",ofs_dats); */
 665
 666                 bufptr = devpriv->last_top_dma;
 667
 668                 for (i = 0; i < ofs_dats; i++) {
 669                         if ((dmabuf[bufptr] & 0xf) != devpriv->act_chanlist[devpriv->act_chanlist_pos]) {       /*  dropout! */
 670                                 printk
 671                                     ("comedi: A/D mode1/3 DMA - channel dropout %d!=%d !\n",
 672                                      (dmabuf[bufptr] & 0xf),
 673                                      devpriv->
 674                                      act_chanlist[devpriv->act_chanlist_pos]);
 675                                 pcl818_ai_cancel(dev, s);
 676                                 s->async->events |=
 677                                     COMEDI_CB_EOA | COMEDI_CB_ERROR;
 678                                 comedi_event(dev, s);
 679                                 return IRQ_HANDLED;
 680                         }
 681
 682                         comedi_buf_put(s->async, dmabuf[bufptr++] >> 4);        /*  get one sample */
 683                         bufptr &= (devpriv->dmasamplsize - 1);
 684
 685                         devpriv->act_chanlist_pos++;
 686                         if (devpriv->act_chanlist_pos >=
 687                                         devpriv->act_chanlist_len) {
 688                                 devpriv->act_chanlist_pos = 0;
 689                         }
 690                         s->async->cur_chan++;
 691                         if (s->async->cur_chan >= devpriv->ai_n_chan) {
 692                                 s->async->cur_chan = 0;
 693                                 devpriv->ai_act_scan--;
 694                         }
 695
 696                         if (!devpriv->neverending_ai)
 697                                 if (devpriv->ai_act_scan == 0) {        /* all data sampled */
 698                                         pcl818_ai_cancel(dev, s);
 699                                         s->async->events |= COMEDI_CB_EOA;
 700                                         comedi_event(dev, s);
 701                                         /* printk("done int ai13 dma\n"); */
 702                                         return IRQ_HANDLED;
 703                                 }
 704                 }
 705
 706                 devpriv->last_top_dma = bufptr;
 707                 bufptr--;
 708                 bufptr &= (devpriv->dmasamplsize - 1);
 709                 dmabuf[bufptr] = MAGIC_DMA_WORD;
 710                 comedi_event(dev, s);
 711                 /* outb(0,0x378); */
 712                 return IRQ_HANDLED;
 713         }
 714
 715         /* outb(0,0x378); */
 716         return IRQ_HANDLED;
 717 }
 718 #endif
 719
 720 /*
 721 ==============================================================================
 722    analog input interrupt mode 1 & 3, 818HD/HG cards
 723 */
 724 static irqreturn_t interrupt_pcl818_ai_mode13_fifo(int irq, void *d)
 725 {
 726         struct comedi_device *dev = d;
 727         struct pcl818_private *devpriv = dev->private;
 728         struct comedi_subdevice *s = &dev->subdevices[0];
 729         int i, len, lo;
 730
 731         outb(0, dev->iobase + PCL818_FI_INTCLR);        /*  clear fifo int request */
 732
 733         lo = inb(dev->iobase + PCL818_FI_STATUS);
 734
 735         if (lo & 4) {
 736                 comedi_error(dev, "A/D mode1/3 FIFO overflow!");
 737                 pcl818_ai_cancel(dev, s);
 738                 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 739                 comedi_event(dev, s);
 740                 return IRQ_HANDLED;
 741         }
 742
 743         if (lo & 1) {
 744                 comedi_error(dev, "A/D mode1/3 FIFO interrupt without data!");
 745                 pcl818_ai_cancel(dev, s);
 746                 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 747                 comedi_event(dev, s);
 748                 return IRQ_HANDLED;
 749         }
 750
 751         if (lo & 2)
 752                 len = 512;
 753         else
 754                 len = 0;
 755
 756         for (i = 0; i < len; i++) {
 757                 lo = inb(dev->iobase + PCL818_FI_DATALO);
 758                 if ((lo & 0xf) != devpriv->act_chanlist[devpriv->act_chanlist_pos]) {   /*  dropout! */
 759                         printk
 760                             ("comedi: A/D mode1/3 FIFO - channel dropout %d!=%d !\n",
 761                              (lo & 0xf),
 762                              devpriv->act_chanlist[devpriv->act_chanlist_pos]);
 763                         pcl818_ai_cancel(dev, s);
 764                         s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 765                         comedi_event(dev, s);
 766                         return IRQ_HANDLED;
 767                 }
 768
 769                 comedi_buf_put(s->async, (lo >> 4) | (inb(dev->iobase + PCL818_FI_DATAHI) << 4));       /*  get one sample */
 770
 771                 devpriv->act_chanlist_pos++;
 772                 if (devpriv->act_chanlist_pos >= devpriv->act_chanlist_len)
 773                         devpriv->act_chanlist_pos = 0;
 774
 775                 s->async->cur_chan++;
 776                 if (s->async->cur_chan >= devpriv->ai_n_chan) {
 777                         s->async->cur_chan = 0;
 778                         devpriv->ai_act_scan--;
 779                 }
 780
 781                 if (!devpriv->neverending_ai)
 782                         if (devpriv->ai_act_scan == 0) {        /* all data sampled */
 783                                 pcl818_ai_cancel(dev, s);
 784                                 s->async->events |= COMEDI_CB_EOA;
 785                                 comedi_event(dev, s);
 786                                 return IRQ_HANDLED;
 787                         }
 788         }
 789
 790         if (len > 0)
 791                 comedi_event(dev, s);
 792         return IRQ_HANDLED;
 793 }
 794
 795 /*
 796 ==============================================================================
 797     INT procedure
 798 */
 799 static irqreturn_t interrupt_pcl818(int irq, void *d)
 800 {
 801         struct comedi_device *dev = d;
 802         struct pcl818_private *devpriv = dev->private;
 803
 804         if (!dev->attached) {
 805                 comedi_error(dev, "premature interrupt");
 806                 return IRQ_HANDLED;
 807         }
 808         /* printk("I\n"); */
 809
 810         if (devpriv->irq_blocked && devpriv->irq_was_now_closed) {
 811                 if ((devpriv->neverending_ai || (!devpriv->neverending_ai &&
 812                                                  devpriv->ai_act_scan > 0)) &&
 813                     (devpriv->ai_mode == INT_TYPE_AI1_DMA ||
 814                      devpriv->ai_mode == INT_TYPE_AI3_DMA)) {
 815                         /* The cleanup from ai_cancel() has been delayed
 816                            until now because the card doesn't seem to like
 817                            being reprogrammed while a DMA transfer is in
 818                            progress.
 819                          */
 820                         struct comedi_subdevice *s = &dev->subdevices[0];
 821                         devpriv->ai_act_scan = 0;
 822                         devpriv->neverending_ai = 0;
 823                         pcl818_ai_cancel(dev, s);
 824                 }
 825
 826                 outb(0, dev->iobase + PCL818_CLRINT);   /* clear INT request */
 827
 828                 return IRQ_HANDLED;
 829         }
 830
 831         switch (devpriv->ai_mode) {
 832         case INT_TYPE_AI1_DMA:
 833         case INT_TYPE_AI3_DMA:
 834                 return interrupt_pcl818_ai_mode13_dma(irq, d);
 835         case INT_TYPE_AI1_INT:
 836         case INT_TYPE_AI3_INT:
 837                 return interrupt_pcl818_ai_mode13_int(irq, d);
 838         case INT_TYPE_AI1_FIFO:
 839         case INT_TYPE_AI3_FIFO:
 840                 return interrupt_pcl818_ai_mode13_fifo(irq, d);
 841 #ifdef PCL818_MODE13_AO
 842         case INT_TYPE_AO1_INT:
 843         case INT_TYPE_AO3_INT:
 844                 return interrupt_pcl818_ao_mode13_int(irq, d);
 845 #endif
 846         default:
 847                 break;
 848         }
 849
 850         outb(0, dev->iobase + PCL818_CLRINT);   /* clear INT request */
 851
 852         if ((!dev->irq) || (!devpriv->irq_free) || (!devpriv->irq_blocked)
 853             || (!devpriv->ai_mode)) {
 854                 comedi_error(dev, "bad IRQ!");
 855                 return IRQ_NONE;
 856         }
 857
 858         comedi_error(dev, "IRQ from unknown source!");
 859         return IRQ_NONE;
 860 }
 861
 862 /*
 863 ==============================================================================
 864    ANALOG INPUT MODE 1 or 3 DMA , 818 cards
 865 */
 866 static void pcl818_ai_mode13dma_int(int mode, struct comedi_device *dev,
 867                                     struct comedi_subdevice *s)
 868 {
 869         struct pcl818_private *devpriv = dev->private;
 870         unsigned int flags;
 871         unsigned int bytes;
 872
 873         printk("mode13dma_int, mode: %d\n", mode);
 874         disable_dma(devpriv->dma);      /*  disable dma */
 875         bytes = devpriv->hwdmasize[0];
 876         if (!devpriv->neverending_ai) {
 877                 bytes = devpriv->ai_n_chan * devpriv->ai_scans * sizeof(short); /*  how many */
 878                 devpriv->dma_runs_to_end = bytes / devpriv->hwdmasize[0];       /*  how many DMA pages we must fiil */
 879                 devpriv->last_dma_run = bytes % devpriv->hwdmasize[0];  /* on last dma transfer must be moved */
 880                 devpriv->dma_runs_to_end--;
 881                 if (devpriv->dma_runs_to_end >= 0)
 882                         bytes = devpriv->hwdmasize[0];
 883         }
 884
 885         devpriv->next_dma_buf = 0;
 886         set_dma_mode(devpriv->dma, DMA_MODE_READ);
 887         flags = claim_dma_lock();
 888         clear_dma_ff(devpriv->dma);
 889         set_dma_addr(devpriv->dma, devpriv->hwdmaptr[0]);
 890         set_dma_count(devpriv->dma, bytes);
 891         release_dma_lock(flags);
 892         enable_dma(devpriv->dma);
 893
 894         if (mode == 1) {
 895                 devpriv->ai_mode = INT_TYPE_AI1_DMA;
 896                 outb(0x87 | (dev->irq << 4), dev->iobase + PCL818_CONTROL);     /* Pacer+IRQ+DMA */
 897         } else {
 898                 devpriv->ai_mode = INT_TYPE_AI3_DMA;
 899                 outb(0x86 | (dev->irq << 4), dev->iobase + PCL818_CONTROL);     /* Ext trig+IRQ+DMA */
 900         };
 901 }
 902
 903 #ifdef unused
 904 /*
 905 ==============================================================================
 906    ANALOG INPUT MODE 1 or 3 DMA rtc, 818 cards
 907 */
 908 static void pcl818_ai_mode13dma_rtc(int mode, struct comedi_device *dev,
 909                                     struct comedi_subdevice *s)
 910 {
 911         struct pcl818_private *devpriv = dev->private;
 912         unsigned int flags;
 913         short *pole;
 914
 915         set_dma_mode(devpriv->dma, DMA_MODE_READ | DMA_AUTOINIT);
 916         flags = claim_dma_lock();
 917         clear_dma_ff(devpriv->dma);
 918         set_dma_addr(devpriv->dma, devpriv->hwdmaptr[0]);
 919         set_dma_count(devpriv->dma, devpriv->hwdmasize[0]);
 920         release_dma_lock(flags);
 921         enable_dma(devpriv->dma);
 922         devpriv->last_top_dma = 0;      /* devpriv->hwdmasize[0]; */
 923         pole = (short *)devpriv->dmabuf[0];
 924         devpriv->dmasamplsize = devpriv->hwdmasize[0] / 2;
 925         pole[devpriv->dmasamplsize - 1] = MAGIC_DMA_WORD;
 926 #ifdef unused
 927         devpriv->rtc_freq = rtc_setfreq_irq(2048);
 928         devpriv->rtc_irq_timer.expires =
 929             jiffies + HZ / devpriv->rtc_freq + 2 * HZ / 100;
 930         devpriv->rtc_irq_timer.data = (unsigned long)dev;
 931         devpriv->rtc_irq_timer.function = rtc_dropped_irq;
 932
 933         add_timer(&devpriv->rtc_irq_timer);
 934 #endif
 935
 936         if (mode == 1) {
 937                 devpriv->int818_mode = INT_TYPE_AI1_DMA_RTC;
 938                 outb(0x07 | (dev->irq << 4), dev->iobase + PCL818_CONTROL);     /* Pacer+DMA */
 939         } else {
 940                 devpriv->int818_mode = INT_TYPE_AI3_DMA_RTC;
 941                 outb(0x06 | (dev->irq << 4), dev->iobase + PCL818_CONTROL);     /* Ext trig+DMA */
 942         };
 943 }
 944 #endif
 945
 946 /*
 947 ==============================================================================
 948    ANALOG INPUT MODE 1 or 3, 818 cards
 949 */
 950 static int pcl818_ai_cmd_mode(int mode, struct comedi_device *dev,
 951                               struct comedi_subdevice *s)
 952 {
 953         struct pcl818_private *devpriv = dev->private;
 954         struct comedi_cmd *cmd = &s->async->cmd;
 955         int divisor1 = 0, divisor2 = 0;
 956         unsigned int seglen;
 957
 958         dev_dbg(dev->class_dev, "pcl818_ai_cmd_mode()\n");
 959         if ((!dev->irq) && (!devpriv->dma_rtc)) {
 960                 comedi_error(dev, "IRQ not defined!");
 961                 return -EINVAL;
 962         }
 963
 964         if (devpriv->irq_blocked)
 965                 return -EBUSY;
 966
 967         start_pacer(dev, -1, 0, 0);     /*  stop pacer */
 968
 969         seglen = check_channel_list(dev, s, devpriv->ai_chanlist,
 970                                     devpriv->ai_n_chan);
 971         if (seglen < 1)
 972                 return -EINVAL;
 973         setup_channel_list(dev, s, devpriv->ai_chanlist,
 974                            devpriv->ai_n_chan, seglen);
 975
 976         udelay(1);
 977
 978         devpriv->ai_act_scan = devpriv->ai_scans;
 979         devpriv->ai_act_chan = 0;
 980         devpriv->irq_blocked = 1;
 981         devpriv->irq_was_now_closed = 0;
 982         devpriv->neverending_ai = 0;
 983         devpriv->act_chanlist_pos = 0;
 984         devpriv->dma_runs_to_end = 0;
 985
 986         if ((devpriv->ai_scans == 0) || (devpriv->ai_scans == -1))
 987                 devpriv->neverending_ai = 1;    /* well, user want neverending */
 988
 989         if (mode == 1) {
 990                 i8253_cascade_ns_to_timer(devpriv->i8253_osc_base, &divisor1,
 991                                           &divisor2, &cmd->convert_arg,
 992                                           TRIG_ROUND_NEAREST);
 993                 if (divisor1 == 1) {    /* PCL718/818 crash if any divisor is set to 1 */
 994                         divisor1 = 2;
 995                         divisor2 /= 2;
 996                 }
 997                 if (divisor2 == 1) {
 998                         divisor2 = 2;
 999                         divisor1 /= 2;
1000                 }
1001         }
1002
1003         outb(0, dev->iobase + PCL818_CNTENABLE);        /* enable pacer */
1004
1005         switch (devpriv->dma) {
1006         case 1:         /*  DMA */
1007         case 3:
1008                 if (devpriv->dma_rtc == 0) {
1009                         pcl818_ai_mode13dma_int(mode, dev, s);
1010                 }
1011 #ifdef unused
1012                 else {
1013                         pcl818_ai_mode13dma_rtc(mode, dev, s);
1014                 }
1015 #else
1016                 else {
1017                         return -EINVAL;
1018                 }
1019 #endif
1020                 break;
1021         case 0:
1022                 if (!devpriv->usefifo) {
1023                         /* IRQ */
1024                         /* printk("IRQ\n"); */
1025                         if (mode == 1) {
1026                                 devpriv->ai_mode = INT_TYPE_AI1_INT;
1027                                 /* Pacer+IRQ */
1028                                 outb(0x83 | (dev->irq << 4),
1029                                      dev->iobase + PCL818_CONTROL);
1030                         } else {
1031                                 devpriv->ai_mode = INT_TYPE_AI3_INT;
1032                                 /* Ext trig+IRQ */
1033                                 outb(0x82 | (dev->irq << 4),
1034                                      dev->iobase + PCL818_CONTROL);
1035                         }
1036                 } else {
1037                         /* FIFO */
1038                         /* enable FIFO */
1039                         outb(1, dev->iobase + PCL818_FI_ENABLE);
1040                         if (mode == 1) {
1041                                 devpriv->ai_mode = INT_TYPE_AI1_FIFO;
1042                                 /* Pacer */
1043                                 outb(0x03, dev->iobase + PCL818_CONTROL);
1044                         } else {
1045                                 devpriv->ai_mode = INT_TYPE_AI3_FIFO;
1046                                 outb(0x02, dev->iobase + PCL818_CONTROL);
1047                         }
1048                 }
1049         }
1050
1051         start_pacer(dev, mode, divisor1, divisor2);
1052
1053 #ifdef unused
1054         switch (devpriv->ai_mode) {
1055         case INT_TYPE_AI1_DMA_RTC:
1056         case INT_TYPE_AI3_DMA_RTC:
1057                 set_rtc_irq_bit(1);     /* start RTC */
1058                 break;
1059         }
1060 #endif
1061         dev_dbg(dev->class_dev, "pcl818_ai_cmd_mode() end\n");
1062         return 0;
1063 }
1064
1065 #ifdef unused
1066 /*
1067 ==============================================================================
1068    ANALOG OUTPUT MODE 1 or 3, 818 cards
1069 */
1070 #ifdef PCL818_MODE13_AO
1071 static int pcl818_ao_mode13(int mode, struct comedi_device *dev,
1072                             struct comedi_subdevice *s, comedi_trig * it)
1073 {
1074         struct pcl818_private *devpriv = dev->private;
1075         int divisor1 = 0, divisor2 = 0;
1076
1077         if (!dev->irq) {
1078                 comedi_error(dev, "IRQ not defined!");
1079                 return -EINVAL;
1080         }
1081
1082         if (devpriv->irq_blocked)
1083                 return -EBUSY;
1084
1085         start_pacer(dev, -1, 0, 0);     /*  stop pacer */
1086
1087         devpriv->int13_act_scan = it->n;
1088         devpriv->int13_act_chan = 0;
1089         devpriv->irq_blocked = 1;
1090         devpriv->irq_was_now_closed = 0;
1091         devpriv->neverending_ai = 0;
1092         devpriv->act_chanlist_pos = 0;
1093
1094         if (mode == 1) {
1095                 i8253_cascade_ns_to_timer(devpriv->i8253_osc_base, &divisor1,
1096                                           &divisor2, &it->trigvar,
1097                                           TRIG_ROUND_NEAREST);
1098                 if (divisor1 == 1) {    /* PCL818 crash if any divisor is set to 1 */
1099                         divisor1 = 2;
1100                         divisor2 /= 2;
1101                 }
1102                 if (divisor2 == 1) {
1103                         divisor2 = 2;
1104                         divisor1 /= 2;
1105                 }
1106         }
1107
1108         outb(0, dev->iobase + PCL818_CNTENABLE);        /* enable pacer */
1109         if (mode == 1) {
1110                 devpriv->int818_mode = INT_TYPE_AO1_INT;
1111                 outb(0x83 | (dev->irq << 4), dev->iobase + PCL818_CONTROL);     /* Pacer+IRQ */
1112         } else {
1113                 devpriv->int818_mode = INT_TYPE_AO3_INT;
1114                 outb(0x82 | (dev->irq << 4), dev->iobase + PCL818_CONTROL);     /* Ext trig+IRQ */
1115         };
1116
1117         start_pacer(dev, mode, divisor1, divisor2);
1118
1119         return 0;
1120 }
1121
1122 /*
1123 ==============================================================================
1124    ANALOG OUTPUT MODE 1, 818 cards
1125 */
1126 static int pcl818_ao_mode1(struct comedi_device *dev,
1127                            struct comedi_subdevice *s, comedi_trig * it)
1128 {
1129         return pcl818_ao_mode13(1, dev, s, it);
1130 }
1131
1132 /*
1133 ==============================================================================
1134    ANALOG OUTPUT MODE 3, 818 cards
1135 */
1136 static int pcl818_ao_mode3(struct comedi_device *dev,
1137                            struct comedi_subdevice *s, comedi_trig * it)
1138 {
1139         return pcl818_ao_mode13(3, dev, s, it);
1140 }
1141 #endif
1142 #endif
1143
1144 /*
1145 ==============================================================================
1146  Start/stop pacer onboard pacer
1147 */
1148 static void start_pacer(struct comedi_device *dev, int mode,
1149                         unsigned int divisor1, unsigned int divisor2)
1150 {
1151         outb(0xb4, dev->iobase + PCL818_CTRCTL);
1152         outb(0x74, dev->iobase + PCL818_CTRCTL);
1153         udelay(1);
1154
1155         if (mode == 1) {
1156                 outb(divisor2 & 0xff, dev->iobase + PCL818_CTR2);
1157                 outb((divisor2 >> 8) & 0xff, dev->iobase + PCL818_CTR2);
1158                 outb(divisor1 & 0xff, dev->iobase + PCL818_CTR1);
1159                 outb((divisor1 >> 8) & 0xff, dev->iobase + PCL818_CTR1);
1160         }
1161 }
1162
1163 /*
1164 ==============================================================================
1165  Check if channel list from user is builded correctly
1166  If it's ok, then program scan/gain logic
1167 */
1168 static int check_channel_list(struct comedi_device *dev,
1169                               struct comedi_subdevice *s,
1170                               unsigned int *chanlist, unsigned int n_chan)
1171 {
1172         unsigned int chansegment[16];
1173         unsigned int i, nowmustbechan, seglen, segpos;
1174
1175         /* correct channel and range number check itself comedi/range.c */
1176         if (n_chan < 1) {
1177                 comedi_error(dev, "range/channel list is empty!");
1178                 return 0;
1179         }
1180
1181         if (n_chan > 1) {
1182                 /*  first channel is every time ok */
1183                 chansegment[0] = chanlist[0];
1184                 /*  build part of chanlist */
1185                 for (i = 1, seglen = 1; i < n_chan; i++, seglen++) {
1186
1187                         /* printk("%d. %d * %d\n",i,
1188                          * CR_CHAN(it->chanlist[i]),CR_RANGE(it->chanlist[i]));*/
1189
1190                         /* we detect loop, this must by finish */
1191
1192                         if (chanlist[0] == chanlist[i])
1193                                 break;
1194                         nowmustbechan =
1195                             (CR_CHAN(chansegment[i - 1]) + 1) % s->n_chan;
1196                         if (nowmustbechan != CR_CHAN(chanlist[i])) {    /*  channel list isn't continuous :-( */
1197                                 printk
1198                                     ("comedi%d: pcl818: channel list must be continuous! chanlist[%i]=%d but must be %d or %d!\n",
1199                                      dev->minor, i, CR_CHAN(chanlist[i]),
1200                                      nowmustbechan, CR_CHAN(chanlist[0]));
1201                                 return 0;
1202                         }
1203                         /*  well, this is next correct channel in list */
1204                         chansegment[i] = chanlist[i];
1205                 }
1206
1207                 /*  check whole chanlist */
1208                 for (i = 0, segpos = 0; i < n_chan; i++) {
1209                         /* printk("%d %d=%d %d\n",CR_CHAN(chansegment[i%seglen]),CR_RANGE(chansegment[i%seglen]),CR_CHAN(it->chanlist[i]),CR_RANGE(it->chanlist[i])); */
1210                         if (chanlist[i] != chansegment[i % seglen]) {
1211                                 printk
1212                                     ("comedi%d: pcl818: bad channel or range number! chanlist[%i]=%d,%d,%d and not %d,%d,%d!\n",
1213                                      dev->minor, i, CR_CHAN(chansegment[i]),
1214                                      CR_RANGE(chansegment[i]),
1215                                      CR_AREF(chansegment[i]),
1216                                      CR_CHAN(chanlist[i % seglen]),
1217                                      CR_RANGE(chanlist[i % seglen]),
1218                                      CR_AREF(chansegment[i % seglen]));
1219                                 return 0;       /*  chan/gain list is strange */
1220                         }
1221                 }
1222         } else {
1223                 seglen = 1;
1224         }
1225         printk("check_channel_list: seglen %d\n", seglen);
1226         return seglen;
1227 }
1228
1229 static void setup_channel_list(struct comedi_device *dev,
1230                                struct comedi_subdevice *s,
1231                                unsigned int *chanlist, unsigned int n_chan,
1232                                unsigned int seglen)
1233 {
1234         struct pcl818_private *devpriv = dev->private;
1235         int i;
1236
1237         devpriv->act_chanlist_len = seglen;
1238         devpriv->act_chanlist_pos = 0;
1239
1240         for (i = 0; i < seglen; i++) {  /*  store range list to card */
1241                 devpriv->act_chanlist[i] = CR_CHAN(chanlist[i]);
1242                 outb(muxonechan[CR_CHAN(chanlist[i])], dev->iobase + PCL818_MUX);       /* select channel */
1243                 outb(CR_RANGE(chanlist[i]), dev->iobase + PCL818_RANGE);        /* select gain */
1244         }
1245
1246         udelay(1);
1247
1248         /* select channel interval to scan */
1249         outb(devpriv->act_chanlist[0] | (devpriv->act_chanlist[seglen -
1250                                                                1] << 4),
1251              dev->iobase + PCL818_MUX);
1252 }
1253
1254 /*
1255 ==============================================================================
1256  Check if board is switched to SE (1) or DIFF(0) mode
1257 */
1258 static int check_single_ended(unsigned int port)
1259 {
1260         if (inb(port + PCL818_STATUS) & 0x20)
1261                 return 1;
1262         return 0;
1263 }
1264
1265 /*
1266 ==============================================================================
1267 */
1268 static int ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
1269                       struct comedi_cmd *cmd)
1270 {
1271         const struct pcl818_board *board = comedi_board(dev);
1272         struct pcl818_private *devpriv = dev->private;
1273         int err = 0;
1274         int tmp, divisor1 = 0, divisor2 = 0;
1275
1276         /* Step 1 : check if triggers are trivially valid */
1277
1278         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
1279         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
1280         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
1281         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1282         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1283
1284         if (err)
1285                 return 1;
1286
1287         /* Step 2a : make sure trigger sources are unique */
1288
1289         err |= cfc_check_trigger_is_unique(cmd->convert_src);
1290         err |= cfc_check_trigger_is_unique(cmd->stop_src);
1291
1292         /* Step 2b : and mutually compatible */
1293
1294         if (err)
1295                 return 2;
1296
1297         /* step 3: make sure arguments are trivially compatible */
1298
1299         if (cmd->start_arg != 0) {
1300                 cmd->start_arg = 0;
1301                 err++;
1302         }
1303
1304         if (cmd->scan_begin_arg != 0) {
1305                 cmd->scan_begin_arg = 0;
1306                 err++;
1307         }
1308
1309         if (cmd->convert_src == TRIG_TIMER) {
1310                 if (cmd->convert_arg < board->ns_min) {
1311                         cmd->convert_arg = board->ns_min;
1312                         err++;
1313                 }
1314         } else {                /* TRIG_EXT */
1315                 if (cmd->convert_arg != 0) {
1316                         cmd->convert_arg = 0;
1317                         err++;
1318                 }
1319         }
1320
1321         if (cmd->scan_end_arg != cmd->chanlist_len) {
1322                 cmd->scan_end_arg = cmd->chanlist_len;
1323                 err++;
1324         }
1325         if (cmd->stop_src == TRIG_COUNT) {
1326                 if (!cmd->stop_arg) {
1327                         cmd->stop_arg = 1;
1328                         err++;
1329                 }
1330         } else {                /* TRIG_NONE */
1331                 if (cmd->stop_arg != 0) {
1332                         cmd->stop_arg = 0;
1333                         err++;
1334                 }
1335         }
1336
1337         if (err)
1338                 return 3;
1339
1340         /* step 4: fix up any arguments */
1341
1342         if (cmd->convert_src == TRIG_TIMER) {
1343                 tmp = cmd->convert_arg;
1344                 i8253_cascade_ns_to_timer(devpriv->i8253_osc_base, &divisor1,
1345                                           &divisor2, &cmd->convert_arg,
1346                                           cmd->flags & TRIG_ROUND_MASK);
1347                 if (cmd->convert_arg < board->ns_min)
1348                         cmd->convert_arg = board->ns_min;
1349                 if (tmp != cmd->convert_arg)
1350                         err++;
1351         }
1352
1353         if (err)
1354                 return 4;
1355
1356         /* step 5: complain about special chanlist considerations */
1357
1358         if (cmd->chanlist) {
1359                 if (!check_channel_list(dev, s, cmd->chanlist,
1360                                         cmd->chanlist_len))
1361                         return 5;       /*  incorrect channels list */
1362         }
1363
1364         return 0;
1365 }
1366
1367 /*
1368 ==============================================================================
1369 */
1370 static int ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1371 {
1372         struct pcl818_private *devpriv = dev->private;
1373         struct comedi_cmd *cmd = &s->async->cmd;
1374         int retval;
1375
1376         dev_dbg(dev->class_dev, "pcl818_ai_cmd()\n");
1377         devpriv->ai_n_chan = cmd->chanlist_len;
1378         devpriv->ai_chanlist = cmd->chanlist;
1379         devpriv->ai_flags = cmd->flags;
1380         devpriv->ai_data_len = s->async->prealloc_bufsz;
1381         devpriv->ai_data = s->async->prealloc_buf;
1382         devpriv->ai_timer1 = 0;
1383         devpriv->ai_timer2 = 0;
1384
1385         if (cmd->stop_src == TRIG_COUNT)
1386                 devpriv->ai_scans = cmd->stop_arg;
1387         else
1388                 devpriv->ai_scans = 0;
1389
1390         if (cmd->scan_begin_src == TRIG_FOLLOW) {       /*  mode 1, 3 */
1391                 if (cmd->convert_src == TRIG_TIMER) {   /*  mode 1 */
1392                         devpriv->ai_timer1 = cmd->convert_arg;
1393                         retval = pcl818_ai_cmd_mode(1, dev, s);
1394                         dev_dbg(dev->class_dev, "pcl818_ai_cmd() end\n");
1395                         return retval;
1396                 }
1397                 if (cmd->convert_src == TRIG_EXT) {     /*  mode 3 */
1398                         return pcl818_ai_cmd_mode(3, dev, s);
1399                 }
1400         }
1401
1402         return -1;
1403 }
1404
1405 /*
1406 ==============================================================================
1407  cancel any mode 1-4 AI
1408 */
1409 static int pcl818_ai_cancel(struct comedi_device *dev,
1410                             struct comedi_subdevice *s)
1411 {
1412         struct pcl818_private *devpriv = dev->private;
1413
1414         if (devpriv->irq_blocked > 0) {
1415                 dev_dbg(dev->class_dev, "pcl818_ai_cancel()\n");
1416                 devpriv->irq_was_now_closed = 1;
1417
1418                 switch (devpriv->ai_mode) {
1419 #ifdef unused
1420                 case INT_TYPE_AI1_DMA_RTC:
1421                 case INT_TYPE_AI3_DMA_RTC:
1422                         set_rtc_irq_bit(0);     /*  stop RTC */
1423                         del_timer(&devpriv->rtc_irq_timer);
1424 #endif
1425                 case INT_TYPE_AI1_DMA:
1426                 case INT_TYPE_AI3_DMA:
1427                         if (devpriv->neverending_ai ||
1428                             (!devpriv->neverending_ai &&
1429                              devpriv->ai_act_scan > 0)) {
1430                                 /* wait for running dma transfer to end, do cleanup in interrupt */
1431                                 goto end;
1432                         }
1433                         disable_dma(devpriv->dma);
1434                 case INT_TYPE_AI1_INT:
1435                 case INT_TYPE_AI3_INT:
1436                 case INT_TYPE_AI1_FIFO:
1437                 case INT_TYPE_AI3_FIFO:
1438 #ifdef PCL818_MODE13_AO
1439                 case INT_TYPE_AO1_INT:
1440                 case INT_TYPE_AO3_INT:
1441 #endif
1442                         outb(inb(dev->iobase + PCL818_CONTROL) & 0x73, dev->iobase + PCL818_CONTROL);   /* Stop A/D */
1443                         udelay(1);
1444                         start_pacer(dev, -1, 0, 0);
1445                         outb(0, dev->iobase + PCL818_AD_LO);
1446                         inb(dev->iobase + PCL818_AD_LO);
1447                         inb(dev->iobase + PCL818_AD_HI);
1448                         outb(0, dev->iobase + PCL818_CLRINT);   /* clear INT request */
1449                         outb(0, dev->iobase + PCL818_CONTROL);  /* Stop A/D */
1450                         if (devpriv->usefifo) { /*  FIFO shutdown */
1451                                 outb(0, dev->iobase + PCL818_FI_INTCLR);
1452                                 outb(0, dev->iobase + PCL818_FI_FLUSH);
1453                                 outb(0, dev->iobase + PCL818_FI_ENABLE);
1454                         }
1455                         devpriv->irq_blocked = 0;
1456                         devpriv->last_int_sub = s;
1457                         devpriv->neverending_ai = 0;
1458                         devpriv->ai_mode = 0;
1459                         devpriv->irq_was_now_closed = 0;
1460                         break;
1461                 }
1462         }
1463
1464 end:
1465         dev_dbg(dev->class_dev, "pcl818_ai_cancel() end\n");
1466         return 0;
1467 }
1468
1469 /*
1470 ==============================================================================
1471  chech for PCL818
1472 */
1473 static int pcl818_check(unsigned long iobase)
1474 {
1475         outb(0x00, iobase + PCL818_MUX);
1476         udelay(1);
1477         if (inb(iobase + PCL818_MUX) != 0x00)
1478                 return 1;       /* there isn't card */
1479         outb(0x55, iobase + PCL818_MUX);
1480         udelay(1);
1481         if (inb(iobase + PCL818_MUX) != 0x55)
1482                 return 1;       /* there isn't card */
1483         outb(0x00, iobase + PCL818_MUX);
1484         udelay(1);
1485         outb(0x18, iobase + PCL818_CONTROL);
1486         udelay(1);
1487         if (inb(iobase + PCL818_CONTROL) != 0x18)
1488                 return 1;       /* there isn't card */
1489         return 0;               /*  ok, card exist */
1490 }
1491
1492 /*
1493 ==============================================================================
1494  reset whole PCL-818 cards
1495 */
1496 static void pcl818_reset(struct comedi_device *dev)
1497 {
1498         const struct pcl818_board *board = comedi_board(dev);
1499         struct pcl818_private *devpriv = dev->private;
1500
1501         if (devpriv->usefifo) { /*  FIFO shutdown */
1502                 outb(0, dev->iobase + PCL818_FI_INTCLR);
1503                 outb(0, dev->iobase + PCL818_FI_FLUSH);
1504                 outb(0, dev->iobase + PCL818_FI_ENABLE);
1505         }
1506         outb(0, dev->iobase + PCL818_DA_LO);    /*  DAC=0V */
1507         outb(0, dev->iobase + PCL818_DA_HI);
1508         udelay(1);
1509         outb(0, dev->iobase + PCL818_DO_HI);    /*  DO=$0000 */
1510         outb(0, dev->iobase + PCL818_DO_LO);
1511         udelay(1);
1512         outb(0, dev->iobase + PCL818_CONTROL);
1513         outb(0, dev->iobase + PCL818_CNTENABLE);
1514         outb(0, dev->iobase + PCL818_MUX);
1515         outb(0, dev->iobase + PCL818_CLRINT);
1516         outb(0xb0, dev->iobase + PCL818_CTRCTL);        /* Stop pacer */
1517         outb(0x70, dev->iobase + PCL818_CTRCTL);
1518         outb(0x30, dev->iobase + PCL818_CTRCTL);
1519         if (board->is_818) {
1520                 outb(0, dev->iobase + PCL818_RANGE);
1521         } else {
1522                 outb(0, dev->iobase + PCL718_DA2_LO);
1523                 outb(0, dev->iobase + PCL718_DA2_HI);
1524         }
1525 }
1526
1527 #ifdef unused
1528 /*
1529 ==============================================================================
1530   Enable(1)/disable(0) periodic interrupts from RTC
1531 */
1532 static int set_rtc_irq_bit(unsigned char bit)
1533 {
1534         unsigned char val;
1535         unsigned long flags;
1536
1537         if (bit == 1) {
1538                 RTC_timer_lock++;
1539                 if (RTC_timer_lock > 1)
1540                         return 0;
1541         } else {
1542                 RTC_timer_lock--;
1543                 if (RTC_timer_lock < 0)
1544                         RTC_timer_lock = 0;
1545                 if (RTC_timer_lock > 0)
1546                         return 0;
1547         }
1548
1549         save_flags(flags);
1550         cli();
1551         val = CMOS_READ(RTC_CONTROL);
1552         if (bit)
1553                 val |= RTC_PIE;
1554         else
1555                 val &= ~RTC_PIE;
1556
1557         CMOS_WRITE(val, RTC_CONTROL);
1558         CMOS_READ(RTC_INTR_FLAGS);
1559         restore_flags(flags);
1560         return 0;
1561 }
1562
1563 /*
1564 ==============================================================================
1565   Restart RTC if something stop it (xntpd every 11 mins or large IDE transfers)
1566 */
1567 static void rtc_dropped_irq(unsigned long data)
1568 {
1569         struct comedi_device *dev = (void *)data;
1570         struct pcl818_private *devpriv = dev->private;
1571         unsigned long flags, tmp;
1572
1573         switch (devpriv->int818_mode) {
1574         case INT_TYPE_AI1_DMA_RTC:
1575         case INT_TYPE_AI3_DMA_RTC:
1576                 mod_timer(&devpriv->rtc_irq_timer,
1577                           jiffies + HZ / devpriv->rtc_freq + 2 * HZ / 100);
1578                 save_flags(flags);
1579                 cli();
1580                 tmp = (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);       /* restart */
1581                 restore_flags(flags);
1582                 break;
1583         }
1584 }
1585
1586 /*
1587 ==============================================================================
1588   Set frequency of interrupts from RTC
1589 */
1590 static int rtc_setfreq_irq(int freq)
1591 {
1592         int tmp = 0;
1593         int rtc_freq;
1594         unsigned char val;
1595         unsigned long flags;
1596
1597         if (freq < 2)
1598                 freq = 2;
1599         if (freq > 8192)
1600                 freq = 8192;
1601
1602         while (freq > (1 << tmp))
1603                 tmp++;
1604
1605         rtc_freq = 1 << tmp;
1606
1607         save_flags(flags);
1608         cli();
1609         val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
1610         val |= (16 - tmp);
1611         CMOS_WRITE(val, RTC_FREQ_SELECT);
1612         restore_flags(flags);
1613         return rtc_freq;
1614 }
1615 #endif
1616
1617 static int pcl818_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1618 {
1619         const struct pcl818_board *board = comedi_board(dev);
1620         struct pcl818_private *devpriv;
1621         int ret;
1622         unsigned long iobase;
1623         unsigned int irq;
1624         int dma;
1625         unsigned long pages;
1626         struct comedi_subdevice *s;
1627
1628         devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
1629         if (!devpriv)
1630                 return -ENOMEM;
1631         dev->private = devpriv;
1632
1633         /* claim our I/O space */
1634         iobase = it->options[0];
1635         printk
1636             ("comedi%d: pcl818:  board=%s, ioport=0x%03lx",
1637              dev->minor, board->name, iobase);
1638         devpriv->io_range = board->io_range;
1639         if ((board->fifo) && (it->options[2] == -1)) {
1640                 /*  we've board with FIFO and we want to use FIFO */
1641                 devpriv->io_range = PCLx1xFIFO_RANGE;
1642                 devpriv->usefifo = 1;
1643         }
1644         if (!request_region(iobase, devpriv->io_range, "pcl818")) {
1645                 comedi_error(dev, "I/O port conflict\n");
1646                 return -EIO;
1647         }
1648
1649         dev->iobase = iobase;
1650
1651         if (pcl818_check(iobase)) {
1652                 comedi_error(dev, "I can't detect board. FAIL!\n");
1653                 return -EIO;
1654         }
1655
1656         dev->board_name = board->name;
1657
1658         /* grab our IRQ */
1659         irq = 0;
1660         if (board->IRQbits != 0) {      /* board support IRQ */
1661                 irq = it->options[1];
1662                 if (irq) {      /* we want to use IRQ */
1663                         if (((1 << irq) & board->IRQbits) == 0) {
1664                                 printk
1665                                     (", IRQ %u is out of allowed range, DISABLING IT",
1666                                      irq);
1667                                 irq = 0;        /* Bad IRQ */
1668                         } else {
1669                                 if (request_irq
1670                                     (irq, interrupt_pcl818, 0, "pcl818", dev)) {
1671                                         printk
1672                                             (", unable to allocate IRQ %u, DISABLING IT",
1673                                              irq);
1674                                         irq = 0;        /* Can't use IRQ */
1675                                 } else {
1676                                         printk(KERN_DEBUG "irq=%u", irq);
1677                                 }
1678                         }
1679                 }
1680         }
1681
1682         dev->irq = irq;
1683         if (irq)
1684                 devpriv->irq_free = 1;   /* 1=we have allocated irq */
1685         else
1686                 devpriv->irq_free = 0;
1687
1688         devpriv->irq_blocked = 0;       /* number of subdevice which use IRQ */
1689         devpriv->ai_mode = 0;   /* mode of irq */
1690
1691 #ifdef unused
1692         /* grab RTC for DMA operations */
1693         devpriv->dma_rtc = 0;
1694         if (it->options[2] > 0) {       /*  we want to use DMA */
1695                 if (RTC_lock == 0) {
1696                         if (!request_region(RTC_PORT(0), RTC_IO_EXTENT,
1697                                             "pcl818 (RTC)"))
1698                                 goto no_rtc;
1699                 }
1700                 devpriv->rtc_iobase = RTC_PORT(0);
1701                 devpriv->rtc_iosize = RTC_IO_EXTENT;
1702                 RTC_lock++;
1703                 if (!request_irq(RTC_IRQ, interrupt_pcl818_ai_mode13_dma_rtc, 0,
1704                                  "pcl818 DMA (RTC)", dev)) {
1705                         devpriv->dma_rtc = 1;
1706                         devpriv->rtc_irq = RTC_IRQ;
1707                         printk(KERN_DEBUG "dma_irq=%u", devpriv->rtc_irq);
1708                 } else {
1709                         RTC_lock--;
1710                         if (RTC_lock == 0) {
1711                                 if (devpriv->rtc_iobase)
1712                                         release_region(devpriv->rtc_iobase,
1713                                                        devpriv->rtc_iosize);
1714                         }
1715                         devpriv->rtc_iobase = 0;
1716                         devpriv->rtc_iosize = 0;
1717                 }
1718         }
1719
1720 no_rtc:
1721 #endif
1722         /* grab our DMA */
1723         dma = 0;
1724         devpriv->dma = dma;
1725         if ((devpriv->irq_free == 0) && (devpriv->dma_rtc == 0))
1726                 goto no_dma;    /* if we haven't IRQ, we can't use DMA */
1727         if (board->DMAbits != 0) {      /* board support DMA */
1728                 dma = it->options[2];
1729                 if (dma < 1)
1730                         goto no_dma;    /* DMA disabled */
1731                 if (((1 << dma) & board->DMAbits) == 0) {
1732                         printk(KERN_ERR "DMA is out of allowed range, FAIL!\n");
1733                         return -EINVAL; /* Bad DMA */
1734                 }
1735                 ret = request_dma(dma, "pcl818");
1736                 if (ret)
1737                         return -EBUSY;  /* DMA isn't free */
1738                 devpriv->dma = dma;
1739                 pages = 2;      /* we need 16KB */
1740                 devpriv->dmabuf[0] = __get_dma_pages(GFP_KERNEL, pages);
1741                 if (!devpriv->dmabuf[0])
1742                         /* maybe experiment with try_to_free_pages() will help .... */
1743                         return -EBUSY;  /* no buffer :-( */
1744                 devpriv->dmapages[0] = pages;
1745                 devpriv->hwdmaptr[0] = virt_to_bus((void *)devpriv->dmabuf[0]);
1746                 devpriv->hwdmasize[0] = (1 << pages) * PAGE_SIZE;
1747                 /* printk("%d %d %ld, ",devpriv->dmapages[0],devpriv->hwdmasize[0],PAGE_SIZE); */
1748                 if (devpriv->dma_rtc == 0) {    /*  we must do duble buff :-( */
1749                         devpriv->dmabuf[1] = __get_dma_pages(GFP_KERNEL, pages);
1750                         if (!devpriv->dmabuf[1])
1751                                 return -EBUSY;
1752                         devpriv->dmapages[1] = pages;
1753                         devpriv->hwdmaptr[1] =
1754                             virt_to_bus((void *)devpriv->dmabuf[1]);
1755                         devpriv->hwdmasize[1] = (1 << pages) * PAGE_SIZE;
1756                 }
1757         }
1758
1759 no_dma:
1760
1761         ret = comedi_alloc_subdevices(dev, 4);
1762         if (ret)
1763                 return ret;
1764
1765         s = &dev->subdevices[0];
1766         if (!board->n_aichan_se) {
1767                 s->type = COMEDI_SUBD_UNUSED;
1768         } else {
1769                 s->type = COMEDI_SUBD_AI;
1770                 devpriv->sub_ai = s;
1771                 s->subdev_flags = SDF_READABLE;
1772                 if (check_single_ended(dev->iobase)) {
1773                         s->n_chan = board->n_aichan_se;
1774                         s->subdev_flags |= SDF_COMMON | SDF_GROUND;
1775                         printk(", %dchans S.E. DAC", s->n_chan);
1776                 } else {
1777                         s->n_chan = board->n_aichan_diff;
1778                         s->subdev_flags |= SDF_DIFF;
1779                         printk(", %dchans DIFF DAC", s->n_chan);
1780                 }
1781                 s->maxdata = board->ai_maxdata;
1782                 s->len_chanlist = s->n_chan;
1783                 s->range_table = board->ai_range_type;
1784                 s->cancel = pcl818_ai_cancel;
1785                 s->insn_read = pcl818_ai_insn_read;
1786                 if ((irq) || (devpriv->dma_rtc)) {
1787                         dev->read_subdev = s;
1788                         s->subdev_flags |= SDF_CMD_READ;
1789                         s->do_cmdtest = ai_cmdtest;
1790                         s->do_cmd = ai_cmd;
1791                 }
1792                 if (board->is_818) {
1793                         if ((it->options[4] == 1) || (it->options[4] == 10))
1794                                 s->range_table = &range_pcl818l_h_ai;   /*  secondary range list jumper selectable */
1795                 } else {
1796                         switch (it->options[4]) {
1797                         case 0:
1798                                 s->range_table = &range_bipolar10;
1799                                 break;
1800                         case 1:
1801                                 s->range_table = &range_bipolar5;
1802                                 break;
1803                         case 2:
1804                                 s->range_table = &range_bipolar2_5;
1805                                 break;
1806                         case 3:
1807                                 s->range_table = &range718_bipolar1;
1808                                 break;
1809                         case 4:
1810                                 s->range_table = &range718_bipolar0_5;
1811                                 break;
1812                         case 6:
1813                                 s->range_table = &range_unipolar10;
1814                                 break;
1815                         case 7:
1816                                 s->range_table = &range_unipolar5;
1817                                 break;
1818                         case 8:
1819                                 s->range_table = &range718_unipolar2;
1820                                 break;
1821                         case 9:
1822                                 s->range_table = &range718_unipolar1;
1823                                 break;
1824                         default:
1825                                 s->range_table = &range_unknown;
1826                                 break;
1827                         }
1828                 }
1829         }
1830
1831         s = &dev->subdevices[1];
1832         if (!board->n_aochan) {
1833                 s->type = COMEDI_SUBD_UNUSED;
1834         } else {
1835                 s->type = COMEDI_SUBD_AO;
1836                 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
1837                 s->n_chan = board->n_aochan;
1838                 s->maxdata = board->ao_maxdata;
1839                 s->len_chanlist = board->n_aochan;
1840                 s->range_table = board->ao_range_type;
1841                 s->insn_read = pcl818_ao_insn_read;
1842                 s->insn_write = pcl818_ao_insn_write;
1843 #ifdef unused
1844 #ifdef PCL818_MODE13_AO
1845                 if (irq) {
1846                         s->trig[1] = pcl818_ao_mode1;
1847                         s->trig[3] = pcl818_ao_mode3;
1848                 }
1849 #endif
1850 #endif
1851                 if (board->is_818) {
1852                         if ((it->options[4] == 1) || (it->options[4] == 10))
1853                                 s->range_table = &range_unipolar10;
1854                         if (it->options[4] == 2)
1855                                 s->range_table = &range_unknown;
1856                 } else {
1857                         if ((it->options[5] == 1) || (it->options[5] == 10))
1858                                 s->range_table = &range_unipolar10;
1859                         if (it->options[5] == 2)
1860                                 s->range_table = &range_unknown;
1861                 }
1862         }
1863
1864         s = &dev->subdevices[2];
1865         if (!board->n_dichan) {
1866                 s->type = COMEDI_SUBD_UNUSED;
1867         } else {
1868                 s->type = COMEDI_SUBD_DI;
1869                 s->subdev_flags = SDF_READABLE;
1870                 s->n_chan = board->n_dichan;
1871                 s->maxdata = 1;
1872                 s->len_chanlist = board->n_dichan;
1873                 s->range_table = &range_digital;
1874                 s->insn_bits = pcl818_di_insn_bits;
1875         }
1876
1877         s = &dev->subdevices[3];
1878         if (!board->n_dochan) {
1879                 s->type = COMEDI_SUBD_UNUSED;
1880         } else {
1881                 s->type = COMEDI_SUBD_DO;
1882                 s->subdev_flags = SDF_WRITABLE;
1883                 s->n_chan = board->n_dochan;
1884                 s->maxdata = 1;
1885                 s->len_chanlist = board->n_dochan;
1886                 s->range_table = &range_digital;
1887                 s->insn_bits = pcl818_do_insn_bits;
1888         }
1889
1890         /* select 1/10MHz oscilator */
1891         if ((it->options[3] == 0) || (it->options[3] == 10))
1892                 devpriv->i8253_osc_base = 100;
1893         else
1894                 devpriv->i8253_osc_base = 1000;
1895
1896         /* max sampling speed */
1897         devpriv->ns_min = board->ns_min;
1898
1899         if (!board->is_818) {
1900                 if ((it->options[6] == 1) || (it->options[6] == 100))
1901                         devpriv->ns_min = 10000;        /* extended PCL718 to 100kHz DAC */
1902         }
1903
1904         pcl818_reset(dev);
1905
1906         printk("\n");
1907
1908         return 0;
1909 }
1910
1911 static void pcl818_detach(struct comedi_device *dev)
1912 {
1913         struct pcl818_private *devpriv = dev->private;
1914
1915         if (devpriv) {
1916                 pcl818_ai_cancel(dev, devpriv->sub_ai);
1917                 pcl818_reset(dev);
1918                 if (devpriv->dma)
1919                         free_dma(devpriv->dma);
1920                 if (devpriv->dmabuf[0])
1921                         free_pages(devpriv->dmabuf[0], devpriv->dmapages[0]);
1922                 if (devpriv->dmabuf[1])
1923                         free_pages(devpriv->dmabuf[1], devpriv->dmapages[1]);
1924 #ifdef unused
1925                 if (devpriv->rtc_irq)
1926                         free_irq(devpriv->rtc_irq, dev);
1927                 if ((devpriv->dma_rtc) && (RTC_lock == 1)) {
1928                         if (devpriv->rtc_iobase)
1929                                 release_region(devpriv->rtc_iobase,
1930                                                devpriv->rtc_iosize);
1931                 }
1932                 if (devpriv->dma_rtc)
1933                         RTC_lock--;
1934 #endif
1935         }
1936         if (dev->irq)
1937                 free_irq(dev->irq, dev);
1938         if (dev->iobase)
1939                 release_region(dev->iobase, devpriv->io_range);
1940 }
1941
1942 static const struct pcl818_board boardtypes[] = {
1943         {"pcl818l", 4, 16, 8, 25000, 1, 16, 16, &range_pcl818l_l_ai,
1944          &range_unipolar5, PCLx1x_RANGE, 0x00fc,
1945          0x0a, 0xfff, 0xfff, 0, 1},
1946         {"pcl818h", 9, 16, 8, 10000, 1, 16, 16, &range_pcl818h_ai,
1947          &range_unipolar5, PCLx1x_RANGE, 0x00fc,
1948          0x0a, 0xfff, 0xfff, 0, 1},
1949         {"pcl818hd", 9, 16, 8, 10000, 1, 16, 16, &range_pcl818h_ai,
1950          &range_unipolar5, PCLx1x_RANGE, 0x00fc,
1951          0x0a, 0xfff, 0xfff, 1, 1},
1952         {"pcl818hg", 12, 16, 8, 10000, 1, 16, 16, &range_pcl818hg_ai,
1953          &range_unipolar5, PCLx1x_RANGE, 0x00fc,
1954          0x0a, 0xfff, 0xfff, 1, 1},
1955         {"pcl818", 9, 16, 8, 10000, 2, 16, 16, &range_pcl818h_ai,
1956          &range_unipolar5, PCLx1x_RANGE, 0x00fc,
1957          0x0a, 0xfff, 0xfff, 0, 1},
1958         {"pcl718", 1, 16, 8, 16000, 2, 16, 16, &range_unipolar5,
1959          &range_unipolar5, PCLx1x_RANGE, 0x00fc,
1960          0x0a, 0xfff, 0xfff, 0, 0},
1961         /* pcm3718 */
1962         {"pcm3718", 9, 16, 8, 10000, 0, 16, 16, &range_pcl818h_ai,
1963          &range_unipolar5, PCLx1x_RANGE, 0x00fc,
1964          0x0a, 0xfff, 0xfff, 0, 1 /* XXX ? */ },
1965 };
1966
1967 static struct comedi_driver pcl818_driver = {
1968         .driver_name    = "pcl818",
1969         .module         = THIS_MODULE,
1970         .attach         = pcl818_attach,
1971         .detach         = pcl818_detach,
1972         .board_name     = &boardtypes[0].name,
1973         .num_names      = ARRAY_SIZE(boardtypes),
1974         .offset         = sizeof(struct pcl818_board),
1975 };
1976 module_comedi_driver(pcl818_driver);
1977
1978 MODULE_AUTHOR("Comedi http://www.comedi.org");
1979 MODULE_DESCRIPTION("Comedi low-level driver");
1980 MODULE_LICENSE("GPL");