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